平衡二叉树的简单实现
定义:
平衡二叉搜索树，又被称为AVL树(Self-balancing binary search tree)，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
图解参考
其实就是基于BST树,区别就是添加节点和删除节点的时候判断树是否平衡,不平衡的时候,通过旋转的方式来让树平衡
/**
* AVL树的节点
*/
public class AVLTreeNode {
/**
* 节点的key值
*/
private int key;
/**
* 左节点
*/
private AVLTreeNode leftNode;
/**
* 右子节点
*/
private AVLTreeNode rightNode;
public AVLTreeNode() {
}
public AVLTreeNode(int key) {
this.key = key;
}
public int getKey() {
return key;
}
public void setKey(int key) {
this.key = key;
}
public AVLTreeNode getLeftNode() {
return leftNode;
}
public void setLeftNode(AVLTreeNode leftNode) {
this.leftNode = leftNode;
}
public AVLTreeNode getRightNode() {
return rightNode;
}
public void setRightNode(AVLTreeNode rightNode) {
this.rightNode = rightNode;
}
@Override
public String toString() {
return "AVLTreeNode{" +
"key=" + key +
'}';
}
}
/**
* AVL树的节点
*/
public class AVLTree {
/**
* 树的根节点
*/
private AVLTreeNode root;
public AVLTreeNode getRoot() {
return root;
}
public void setRoot(AVLTreeNode root) {
this.root = root;
}
/**
* 添加树的节点
*
* @param node
*/
public void add(AVLTreeNode node) {
//跟节点不存在的情况下
if (root == null) {
root = node;
return;
}
//添加
addNode(root, node);
//添加完一个节点后,判断树是否平衡,不平衡就需要旋转
int leftHeight = getTreeHeight(root.getLeftNode());
int rightHeight = getTreeHeight(root.getRightNode());
//左节点多两个,右旋转
if (leftHeight - rightHeight > 1) {
//如果左子节点的右节点多了,那么就需要先旋转一次
//判断是都需要左旋转一次
//如果左子树的右子树的节点多,那么需要先左旋一次
if (getTreeHeight(root.getLeftNode().getRightNode()) > getTreeHeight(root.getLeftNode().getLeftNode())) {
leftRotation(getRoot().getLeftNode());
}
rightRotation(root);
} else if (rightHeight - leftHeight > 1) {
//判断是否需要右旋转一次
if (getTreeHeight(root.getRightNode().getRightNode()) < getTreeHeight(root.getRightNode().getLeftNode())) {
rightRotation(getRoot().getRightNode());
}
//左旋转
leftRotation(root);
}
}
/**
* 添加节点
*
* @param target 待比较的节点
* @param node 待添加节点
*/
private void addNode(AVLTreeNode target, AVLTreeNode node) {
//小于就添加到左子树,大于就到右子树,等于就等于重复,不处理
int targetKey = target.getKey();
int key = node.getKey();
if (targetKey == key) {
System.out.println("当前节点已存在!");
return;
}
if (key < targetKey) {
if (target.getLeftNode() == null) {
target.setLeftNode(node);
} else {
addNode(target.getLeftNode(), node);
}
} else {
if (target.getRightNode() == null) {
target.setRightNode(node);
} else {
addNode(target.getRightNode(), node);
}
}
}
/**
* 查找
*
* @param key
* @return
*/
public AVLTreeNode search(int key) {
if (root == null) {
return null;
}
return searchNode(root, key);
}
/**
* 搜索节点
*
* @param target 待搜索节点
* @param key
* @return
*/
private AVLTreeNode searchNode(AVLTreeNode target, int key) {
if (target == null) {
return null;
}
int targetKey = target.getKey();
if (targetKey == key) {
return target;
}
if (key < targetKey) {
return searchNode(target.getLeftNode(), key);
} else {
return searchNode(target.getRightNode(), key);
}
}
/**
* 中序遍历
*/
public void midTraverse() {
if (root == null) {
return;
}
midTraverse(root);
}
/**
* 遍历
*
* @param node
*/
private void midTraverse(AVLTreeNode node) {
if (node.getLeftNode() != null) {
midTraverse(node.getLeftNode());
}
System.out.println(node);
if (node.getRightNode() != null) {
midTraverse(node.getRightNode());
}
}
/**
* 删除节点
*
* @param key
*/
public void delete(int key) {
//删除节点需要先找到待删除节点的父节点
AVLTreeNode parentNode = searchParentNode(root, key);
if (parentNode == null) {
System.out.println("未找到待删除节点的父节点!");
return;
}
System.out.println("parentNode=" + parentNode);
//找到待删除的节点
AVLTreeNode target = (parentNode.getLeftNode() != null && parentNode.getLeftNode().getKey() == key) ?
parentNode.getLeftNode() : parentNode.getRightNode();
//删除分为三种情况
//1.删除叶子节点
//2.删除有一个子节点的节点
//3.删除有两个子节点的子节点
int childNum = getChildNum(target);
if (childNum != 2) {
deleteChildNode(parentNode, target);
} else {
//有两个子节点,那么就需要做一次替换,然后删除
//找到右子树的最小的节点,删除该节点,然后把值替换待删除节点
//为什么是右子树的最小值呢,因为右子树的值都大于当前节点和左子树,选最小是因为右子树的值都要大于父节点
AVLTreeNode minNode = getMinRightNode(target.getRightNode());
//删除该节点
delete(minNode.getKey());
//移动节点
target.setKey(minNode.getKey());
}
//删除完毕后判断旋转
}
/**
* @param node
* @return
*/
public AVLTreeNode getMinRightNode(AVLTreeNode node) {
AVLTreeNode temp = node;
while (temp.getLeftNode() != null) {
temp = temp.getLeftNode();
}
return temp;
}
/**
* 删除指定的子节点
*
* @param parentNode
* @param target
*/
private void deleteChildNode(AVLTreeNode parentNode, AVLTreeNode target) {
//判断是哪个节点,找到后,直接指向待删除节点的下一个节点
//如果子节点没有子节点,那么也是直接变成null
if (parentNode.getLeftNode() == target) {
parentNode.setLeftNode(target.getLeftNode());
} else {
parentNode.setRightNode(target.getRightNode());
}
}
/**
* 搜索父节点
*
* @param target 待搜索节点
* @param key
* @return
*/
private AVLTreeNode searchParentNode(AVLTreeNode target, int key) {
if (target == null) {
return null;
}
//判断当前节点是否就是要找的父节点
//匹配任何一个子节点,那么就算找到
if ((target.getLeftNode() != null && target.getLeftNode().getKey() == key)
|| (target.getRightNode() != null && target.getRightNode().getKey() == key)) {
return target;
}
if (key < target.getKey()) {
return searchParentNode(target.getLeftNode(), key);
} else {
return searchParentNode(target.getRightNode(), key);
}
}
/**
* 该节点左右子节点的数量
* 叶子节点返回0
* 有左子节点/右子节点中的一个返回1
* 同时存在左右子节点 返回2
*
* @param node
* @return
*/
private int getChildNum(AVLTreeNode node) {
int num = 0;
if (node.getLeftNode() != null) {
num++;
}
if (node.getRightNode() != null) {
num++;
}
return num;
}
/**
* 获取以该节点为父节点的子树的高度
*
* @return
*/
public int getTreeHeight(AVLTreeNode node) {
if (node == null) {
return 0;
}
return Math.max(node.getLeftNode() == null ? 0 : getTreeHeight(node.getLeftNode()),
node.getRightNode() == null ? 0 : getTreeHeight(node.getRightNode())) + 1;
}
/**
* 右边节点多两个的时候,进行左旋转
*
* @param node
*/
public void leftRotation(AVLTreeNode node) {
//创建新的节点
AVLTreeNode newNode = new AVLTreeNode(node.getKey());
//左节点指向node的左节点
newNode.setLeftNode(node.getLeftNode());
//右子节点指向node的右子节点的左节点
newNode.setRightNode(node.getRightNode().getLeftNode());
//node的左子节点指向newNode
node.setLeftNode(newNode);
//node的值变为右子节点的值
node.setKey(node.getRightNode().getKey());
//把右子节点删除掉
node.setRightNode(node.getRightNode().getRightNode());
}
/**
* 左边节点多两个的时候,进行右旋转
*
* @param node
*/
public void rightRotation(AVLTreeNode node) {
//创建新的节点
AVLTreeNode newNode = new AVLTreeNode(node.getKey());
//右节点指向node节点的右节点
newNode.setRightNode(node.getRightNode());
//左子节点指向node节点的左子节点的右子及诶单
newNode.setLeftNode(node.getLeftNode().getRightNode());
//node的右子节点指向newNode
node.setRightNode(newNode);
//node的值变为右子节点的值
node.setKey(node.getLeftNode().getKey());
//把左子节点删除掉
node.setLeftNode(node.getLeftNode().getLeftNode());
}
}
/**
* 测试
*/
public class TestClass {
/**
* 测试代码
*
* @param args
*/
public static void main(String[] args) {
// int[] array = new int[]{4,3,6,5,7,8};
//{10,12, 8, 9, 7, 6}
// int[] array = new int[]{10, 12, 8, 9, 7, 6};
int[] array = { 10, 11, 7, 6, 8, 9 };
AVLTree tree = new AVLTree();
for (int i = 0; i < array.length; i++) {
int key = array[i];
AVLTreeNode node = new AVLTreeNode(key);
tree.add(node);
}
System.out.println("中序遍历");
tree.midTraverse();
System.out.println("树的高度" + tree.getTreeHeight(tree.getRoot()));
System.out.println("左子树的高度" + tree.getTreeHeight(tree.getRoot().getLeftNode()));
System.out.println("右子树的高度" + tree.getTreeHeight(tree.getRoot().getRightNode()));
}
}