平衡二叉树:
解决了二叉排序树退化成链表的问题,每次插入新的节点时,都判断一下树的平衡是否已经被打破(每一颗树的左右子树高度差<=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;
}
//双旋转
}