平衡二叉樹:
解決了二叉排序樹退化成鏈表的問題,每次插入新的節點時,都判斷一下樹的平衡是否已經被打破(每一顆樹的左右子樹高度差<=1),如果發現已經打破,則根據實際情況進行左旋轉、右旋轉、左右雙旋轉、右左雙旋轉。
代碼:
package cn.agan.avltree;
/**
* 平衡二叉樹:它是一顆空樹,或它的左右兩個子樹的高度差的絕對只不超過1,並且左右兩個子樹都是一顆平衡二叉樹。
* 平衡二叉樹的常用實現方法有:紅黑樹、AVL、替罪羊樹、Treap 伸展樹
*/
public class AVLTreeDemo {
public static void main(String[] args) {
int[] a = {4,3,6,5,7,8};
//創建一個avltree
AVLTree avlTree = new AVLTree();
for (int i = 0; i < a.length; i++) {
avlTree.add(new Node(a[i]));
}
//遍歷
System.out.println("中序遍歷:");
avlTree.infixOrder();
//樹的高度:
System.out.println("樹的高度:"+ avlTree.height());
System.out.printf("樹的左子樹高度:%d,右子樹的高度:%d\n",
avlTree.getRoot().getLeft().height(), avlTree.getRoot().getRight().height());
}
}
//創建avl樹
class AVLTree {
private Node root;
public Node getRoot() {
return root;
}
public void setRoot(Node root) {
this.root = root;
}
//添加節點
public void add(Node node) {
if (root == null) {
root = node;
} else {
root.add(node);
}
}
//終須遍歷
public void infixOrder() {
if (root != null) {
root.infixOrder();
} else {
System.out.println("樹爲空");
}
}
//獲取樹的高度
public int height() {
if (root != null) {
return root.height();
} else {
System.out.println("樹爲空");
}
return 0;
}
//查找要刪除的節點
public Node search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
//查找父節點
public Node searchParent(int value) {
if (root == null) {
return null;
} else {
return root.searchParent(value);
}
}
/**
* 返回以node爲根的二叉排序樹的最小節點的值,刪除node爲根節點的二叉排序樹的最小節點
* @param node 傳入的節點(當作二叉排序樹的根節點)
* @return 返回的以node爲根節點的二叉排序樹的最小節點的值
*/
public int delRightTreeMin(Node node) {
Node target = node;
//循環查找左子結點,直到找到最小值
while (target.getLeft() != null) {
target = target.getLeft();
}
//此時target指向最小值
delNode(target.getValue());
return node.getValue();
}
//刪除節點
public void delNode(int val) {
if (root == null) {
return;
} else {
Node targetNode = search(val);
if (targetNode == null) {
return;
}
//如果targetNode沒有父節點,則這個是根節點
if (root.getLeft() == null && root.getRight() == null) {
root = null;
}
//找到其父節點
Node parent = searchParent(val);
if (targetNode.getLeft() == null && targetNode.getRight() == null) { //葉子節點
//判斷
if (parent.getLeft() != null && parent.getLeft().getValue() == val) {
parent.setLeft(null);
} else if (parent.getRight() != null && parent.getRight().getValue() == val) {
parent.setRight(null);
}
} else if (targetNode.getLeft() != null && targetNode.getRight() != null) { //有兩個子樹的節點
int minVal = delRightTreeMin(targetNode.getRight());
targetNode.setValue(minVal);
} else { //只有一顆子樹的節點
//如果要刪除的節點有左子節點
if (targetNode.getLeft() != null) {
//如果是parent的左子節點
if (parent.getLeft().getValue() == val) {
parent.setLeft(targetNode.getLeft());
} else { //targetNode是parent的右子節點
parent.setRight(targetNode.getLeft());
}
} else { //要刪除的節點有右子節點
if (parent.getLeft().getValue() == val) {
parent.setLeft(targetNode.getRight());
} else { //targetNode是parent的右子節點
parent.setRight(targetNode.getRight());
}
}
}
}
}
}
//節點
class Node {
private int value;
private Node left;
private Node right;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}
public Node(int value) {
this.value = value;
}
//返回左子樹的高度
public int leftHeight() {
if (left == null) {
return 0;
}
return left.height();
}
//返回右子樹的高度
public int rightHeight() {
if (right == null) {
return 0;
}
return right.height();
}
//返回當前節點的高度,以該節點爲根節點的樹的高度
public int height() {
return Math.max(left == null ? 0: left.height(), right == null ? 0 : right.height()) + 1;
}
//查找要刪除的節點
public Node search(int value) {
if (this.value == value) {
//找到
return this;
} else if (value < this.value) { //應該往當前節點的左邊查找
if (left == null) {
return null;
}
return this.left.search(value);
} else { //只能往右邊查找了
if (right == null) {
return null;
}
return right.search(value);
}
}
//查找目標節點的父節點
public Node searchParent(int value) {
if ((left != null && left.value == value) ||
(right != null && right.value == value)){
return this;
} else { //如果查找的值小於當前節點的值,並且當前節點的左子節點不爲空
if (value < this.value && left != null) {
return left.searchParent(value);
} else if (value >= this.value && right != null) {
return right.searchParent(value); //向右子樹查找
} else {
return null;
}
}
}
//add 添加節點, 遞歸的形式添加
public void add(Node node) {
if (node == null) {
return;
}
//
if (node.value < this.value) {
if (left == null) {
left = node;
} else {
left.add(node);
}
} else {
if (right == null) {
right = node;
} else {
right.add(node);
}
}
//添加完一個節點後,如果右子樹的高度 - 左子樹的高度 > 1,左旋轉
if (rightHeight() - leftHeight() > 1) {
//如果它的右子樹的左子樹的高度大於它的右子樹的右子樹高度
//先對它的右子節點進行右旋轉,然後再對當前節點進行左旋轉
if (right != null && right.leftHeight() > right.rightHeight()) {
right.rightRotate();
leftRotate();
} else {
leftRotate();
}
return;
}
//如果左子樹的高度 - 右子樹的高度 > 2, 右旋轉
if (leftHeight() - rightHeight() > 1) {
//如果它的左子樹的右子樹高度大於它的左子樹的高度
if (left != null && left.rightHeight() > left.leftHeight()) {
//先對當前節點的左節點 -> 進行左旋轉
left.leftRotate();
//再對當前節點進行右旋轉
rightRotate();
} else {
rightRotate();
}
return;
}
}
//中序遍歷
public void infixOrder() {
if (this.left != null) {
this.left.infixOrder();
}
System.out.println(this);
if (this.right != null) {
this.right.infixOrder();
}
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
//左旋轉
private void leftRotate() {
//創建新的節點,以當前根節點的值
Node newNode = new Node(value);
//把新的節點的左子樹設置成當前節點的左子樹
newNode.left = left;
//把新的節點的右子樹設置成當前節點的右子樹的左子樹
newNode.right = right.left;
//把當前節點的值替換成右子節點的值
value = right.value;
//把當前節點的右子樹設置成當前節點的右子樹的右子樹
right = right.right;
//把當前節點的左子結點設置成新的節點
left = newNode;
}
//右旋轉
private void rightRotate() {
Node newNode = new Node(value);
newNode.right = right;
newNode.left = left.right;
value = left.value;
left = left.left;
right = newNode;
}
//雙旋轉
}