1、平衡二叉树
- 概念：平衡二叉树（Balanced Binary Tree）又被称为AVL树，首先这是一棵 “二叉排序树” ，其次它的左右两个子树的高度差的绝对值不超过1，这很好的解决了二叉查找树退化成链表的问题；
- 举例：如下，左边二叉排序树的左子树高度为2，右子树高度为0，二者的高度差为2，这是一棵非平衡二叉树；右边二叉树的左子树高度为1，右子树高度为2，二者的高度差为1，所以是一棵平衡二叉树。
- 调整措施：左旋转、右旋转和左右双旋转；简而言之，就是更换根节点，使左右子树的高度差小于等于1；上图为使用一次右旋转，将非平衡二叉树转为平衡二叉树。
2、Java代码 -- 创建平衡二叉树
/*
平衡二叉树的创建，和调整方法（左旋转，右旋转）
*/
package DataStructures.avl;
/**
* @author yhx
* @date 2020/10/22
*/
public class AVLTreeDemo {
public static void main(String[] args) {
//int[] arr = {10, 12, 8, 9, 7, 6};
int[] arr = {1, 2, 3, 5, 7, 10};
AVLTree avlTree = new AVLTree();
for (int i : arr) {
avlTree.add(new Node(i));
}
System.out.println("构建二叉排序树，中序遍历为：");
avlTree.midOrder();
System.out.println();
System.out.println("树的高度 = " + avlTree.getRoot().height());
System.out.println("左子树的高度 = " + avlTree.getRoot().leftHeight());
System.out.println("右子树的高度 = " + avlTree.getRoot().rightHeight());
}
}
/**
* 创建平衡二叉树
*/
class AVLTree {
private Node root;
public Node getRoot() {
return root;
}
/**
* 添加节点的方法
*
* @param node 待添加节点
*/
public void add(Node node) {
if (root == null) {
root = node;
} else {
root.add(node);
}
}
/**
* 删除节点--查找要删除的节点
*
* @param value 要查找节点的值
* @return 返回要删除的节点
*/
public Node search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
/**
* 删除节点--查找要删除节点的父节点
*
* @param value 要查找节点的值
* @return 返回要删除的节点的父节点
*/
public Node searchParent(int value) {
if (root == null) {
return null;
} else {
return root.searchParent(value);
}
}
/**
* 删除节点--找到值最小的节点，并将其删除
*
* @param node 二叉排序树的根节点
* @return 以node为根节点的二叉排序树，返回其最小值的节点
*/
public int delRightTreeMin(Node node) {
Node target = node;
// 循环查找左节点，找到最小值
while (target.left != null) {
target = target.left;
}
// 删除最小值的节点
delNode(target.value);
return target.value;
}
/**
* 删除节点--汇总
*
* @param value 要删除节点的值
*/
public void delNode(int value) {
if (root == null) {
return;
} else {
// 查找要删除的节点和删除节点的父节点
Node targetNode = search(value);
Node parent = searchParent(value);
// 1、如果没找到
if (targetNode == null) {
return;
}
// 2、当前二叉排序树只有本身这个节点
if (root.left == null & root.right == null) {
// 置空返回
root = null;
return;
}
// 3、如果要删除的节点是叶子结点
if (targetNode.left == null && targetNode.right == null) {
// 判断删除节点是左节点还是右节点，对应从父节点执行删除操作（置空）
// 左
if (parent.left != null && parent.left.value == value) {
parent.left = null;
}
// 右
else if (parent.right != null && parent.right.value == value) {
parent.right = null;
}
}
// 4、如果要删除的节点有两棵子树
else if (targetNode.left != null && targetNode.right != null) {
// 从右子树找到最小值的节点，替换当前待删除节点
// 也可从左子树找到最大值的节点来替换
int minVal = delRightTreeMin(targetNode.right);
targetNode.value = minVal;
}
// 5、删除的节点只有一棵子树
else {
// 子树是左子节点
if (targetNode.left != null) {
if (parent != null) {
if (parent.left.value == value) {
parent.left = targetNode.left;
} else {
parent.right = targetNode.left;
}
} else {
root = targetNode.left;
}
}
// 子树是右子节点
else {
if (parent != null) {
if (parent.left.value == value) {
parent.left = targetNode.right;
} else {
parent.right = targetNode.right;
}
} else {
root = targetNode.right;
}
}
}
}
}
/**
* 中序遍历
*/
public void midOrder() {
if (root != null) {
root.midOrder();
} else {
System.out.println("二叉树为空，不能遍历");
}
}
}
/**
* 节点Node类
*/
class Node {
int value;
Node left;
Node right;
/**
* 构造器
*
* @param value 节点的值
*/
public Node(int value) {
this.value = value;
}
/**
* 返回以当前节点为根节点的二叉树的高度
*
* @return 树的高度
*/
public int height() {
// 如果子树为空，就返回0+1，否则递归操作
return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
}
/**
* 返回左子树高度
*
* @return 左子树高度
*/
public int leftHeight() {
if (left == null) {
return 0;
}
return left.height();
}
/**
* 返回右子树高度
*
* @return 右子树高度
*/
public int rightHeight() {
if (right == null) {
return 0;
}
return right.height();
}
/**
* 二叉排序树的平衡方法 -- 左旋转
* 当二叉排序树 （右子树高度 - 左子树高度）>1时，左旋转
*/
private void leftRotate() {
// 以当前根节点的值，创建新节点
Node newNode = new Node(value);
// 新节点的左子树 = 原根节点的左子树
newNode.left = left;
// 新节点的右子树 = 原根节点的右子树的左子树
newNode.right = right.left;
// 新节点的值 = 原根节点右子树的值
value = right.value;
// 原根节点的右子树 = 原根节点的右子树的右子树
right = right.right;
// 原根节点的左子树 = 新节点
left = newNode;
}
/**
* 二叉排序树的平衡方法 -- 右旋转
* 当二叉排序树 （左子树高度 - 右子树高度）>1时，右旋转
*/
private void rightRotate() {
// 以当前根节点的值，创建新节点
Node newNode = new Node(value);
// 新节点的右子树 = 原根节点的右子树
newNode.right = right;
// 新节点的左子树 = 原根节点的左子树的右子树
newNode.left = left.right;
// 新节点的值 = 原根节点左子树的值
value = left.value;
// 原根节点的左子树 = 原根节点的左子树的左子树
left = left.left;
// 原根节点的右子树 = 新节点
right = newNode;
}
/**
* 添加节点
* 传入的节点值小于当前节点值，放在左子树，否则放在右子树
*
* @param node 待添加的节点
*/
public void add(Node node) {
if (node == null) {
return;
}
// 传入的节点值小于当前节点值，放在左子树，否则放在右子树
if (node.value < this.value) {
// 如果左子节点为空，就挂在左子节点上
if (this.left == null) {
this.left = node;
}
// 如果左子节点不为空，就递归添加
else {
this.left.add(node);
}
} else {
if (this.right == null) {
this.right = node;
} else {
this.right.add(node);
}
}
// 当添加完一个新节点后，如果（右子树高度 - 左子树高度）>1，就左旋转，使二叉树平衡
if (rightHeight() - leftHeight() > 1) {
// 如果它右子树的左子树高度大于它右子树的右子树高度，要先对它的右子树进行右旋转，再对根节点本身进行左旋转
if (right != null && right.leftHeight() > right.rightHeight()) {
right.rightHeight();
}
leftRotate();
return;
}
// 当添加完一个新节点后，如果（左子树高度 - 右子树高度）>1，就右旋转，使二叉树平衡
if (leftHeight() - rightHeight() > 1) {
// 如果它左子树的右子树高度大于它左子树的左子树高度，要先对它的左子树进行左旋转，再对根节点本身进行右旋转
if (left != null && left.rightHeight() > left.leftHeight()) {
left.leftHeight();
}
rightRotate();
}
}
/**
* 删除节点--查找要删除的节点
*
* @param value 希望删除的节点的值
* @return 返回节点，否则返回null
*/
public Node search(int value) {
if (value == this.value) {
return this;
}
// 值小于当前节点值，向左子树查找
else if (value < this.value) {
if (this.left == null) {
return null;
}
return this.left.search(value);
}
// 向右子树查找
else {
if (this.right == null) {
return null;
}
return this.right.search(value);
}
}
/**
* 删除节点--查找要删除节点的父节点
*
* @param value 要查找的值
* @return 返回查找节点的父节点
*/
public Node searchParent(int value) {
if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
return this;
} else {
// 左子树查找
if (value < this.value && this.left != null) {
return this.left.searchParent(value);
}
// 右子树查找
else if (value >= this.value && this.right != null) {
return this.right.searchParent(value);
}
// 没有找到父节点
else {
return null;
}
}
}
/**
* 中序遍历
*/
public void midOrder() {
if (this.left != null) {
this.left.midOrder();
}
System.out.println(this);
if (this.right != null) {
this.right.midOrder();
}
}
@Override
public String toString() {
return "Node [ Value" + value + " ]";
}
}3、运行结果
构建二叉排序树，中序遍历为：
Node [ Value1 ]
Node [ Value2 ]
Node [ Value3 ]
Node [ Value5 ]
Node [ Value7 ]
Node [ Value10 ]
树的高度 = 3
左子树的高度 = 2
右子树的高度 = 2
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
