排序二叉树和平衡二叉树
概述
对于一组元素 [7, 3, 10, 12, 5, 1, 9] 可以有很多种存储方式，但无论使用哪种数据结构，都或多或少有缺陷。比如使用线性结构存储，排序方便，但查找效率低。二叉排序树的特点就是能在保证元素有序的同时，提高查找的效率。
二叉排序树的定义
二叉排序树，也叫二叉查找树，二叉搜索树，英文名 Binary Sort Tree（BST）。它或者是一颗空树，或者是一颗具有以下性质的二叉树
- 若左子树不为空，则左子树上所有结点的值均小于它的根结点的值
- 若右子树不为空，则右子树上所有结点的值均大于它的根结点的值
- 左、右子树也分别为二叉排序树
序列 [7, 3, 10, 12, 5, 1, 9] 以二叉排序树存储的结构如图：
创建二叉排序树 & 添加 & 查找 & 遍历
值得注意的是，对二叉排序树作中序遍历，结果正好是一个有序序列。
public class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
/**
* 向子树添加结点
* @param node 要添加的结点
*/
public void add(Node node) {
if (node != null) {
// 添加的结点比当前结点的值小
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);
}
}
}
}
/**
* 中序遍历
*/
public void midShow() {
// 输出左结点内容
if (left != null) {
left.midShow();
}
// 输出当前结点内容
System.out.println(value);
// 输出右结点内容
if (right != null) {
right.midShow();
}
}
/**
* 查找结点
* @param value 目标结点的值
* @return 目标结点
*/
public Node search(int value) {
if (this.value == value) {
return this;
} else if (value < this.value) {
if (left == null) {
return null;
}
return left.search(value);
} else {
if (right == null) {
return null;
}
return right.search(value);
}
}
}
public class BinarySortTree {
private Node root;
/**
* 向二叉排序树添加结点
* @param node
*/
public void add(Node node) {
if (root == null) {
root = node;
} else {
root.add(node);
}
}
/**
* 中序遍历
*/
public void midShow() {
if (root != null) {
root.midShow();
}
}
/**
* 查找结点
* @param value 目标结点的值
* @return 目标结点
*/
public Node search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
}
删除结点
二叉排序树的删除操作相对麻烦些，我们不能像以前那样直接删除结点对应的整个子树，而是要把子结点保留下来，并重新拼接成新的排序二叉树。针对不同的情况，也有不同的应对策略：
- 删除叶子结点。直接砍掉就好了，不会对其他结点有影响。
- 删除只有一个子结点的结点。子结点代替原结点的位置。
- 删除有两个子结点的结点。被删除结点同时也是对应二叉排序子树的根结点，根据二叉排序树的性质，根结点就是序列的中间值，所以要补上中间值的位置，要用中间值的后一位的元素（对应右子树的最小结点）或前一位元素（对应左子树的最大结点）
public class BinarySortTree {
private Node root;
......
/**
* 删除结点
* @param value 要删除结点的值
*/
public void delete(int value) {
if (root != null) {
// 找到目标结点
Node target = search(value);
if (target != null) {
// 找到目标结点的父结点
Node parent = searchParent(value);
// 要删除的结点是叶子结点
if (target.left == null && target.right == null) {
// 要删除的结点是父结点的左子结点
if (parent.left.value() == value) {
parent.left = null;
// 要删除的结点是父结点的右子结点
} else {
parent.right = null;
}
// 要删除的结点有两个子结点
} else if (target.left != null && target.right != null) {
// 删除右子树中值最小的结点，并获取该结点的值
int min = deleteMin(target.right);
// 替换目标结点的值
target.value = min;
// 要删除的结点只有一个子结点
} else {
// 有左子结点
if (target.left != null) {
// 要删除的结点是父结点的左子结点
if (parent.left.value() == value) {
// 父结点的左子结点指向目标结点的左子结点
parent.left = target.left;
// 要删除的结点是父结点的右子结点
} else {
// 父结点的右子结点指向目标结点的左子结点
parent.right = target.left;
}
// 有右子结点
} else {
// 要删除的结点是父结点的左子结点
if (parent.left.value == value) {
// 父结点的左子结点指向目标结点的左子结点
parent.left = target.right;
// 要删除的结点是父结点的右子结点
} else {
parent.right = target.right;
}
}
}
}
}
}
/**
* 删除最小值结点
* @param node 目标二叉树的根结点
* @return 最小值
*/
public int deleteMin(Node node) {
Node target = node;
while (target.left != null) {
target = target.left();
}
delete(target.value);
return target.value;
}
/**
* 查找父结点
* @param value 目标父结点的子结点的值
* @return 目标父结点
*/
public Node searchParent(int value) {
if (root == null) {
return null;
} else {
return root.searchParent(value);
}
}
}
public class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
......
/**
* 查找结点
* @param value 目标结点的值
* @return 目标结点
*/
public Node search(int value) {
if (this.value == value) {
return this;
} else if (value < this.value) {
if (left == null) {
return null;
}
return left.search(value);
} else {
if (right == null) {
return null;
}
return 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 (this.left != null && this.value > value) {
return this.left.searchParent(value);
} else if (this.right != null && this.value < value) {
return this.right.searchParent(value);
} else {
return null;
}
}
}
}
平衡二叉树
上述的排序二叉树，如果结构良好，那么检索数据时的时间开销为 O(logn)，其中 n 为结点个数。但如果排序二叉树的结构畸形，那么最坏时间开销可能为 O(n)，如下图所示：
这样也满足二叉排序树的定义，但和单链表无异，如果是这样的话，那使用排序二叉树还有什么意义呢？所以我们下一步要思考的是如何保证一颗排序二叉树结构良好
平衡二叉树，也叫 AVL 树，除了具有二叉排序树的性质以外，它要求每一个结点的左右子树的高度之差的绝对值不超过一
每一次插入新元素后，树的平衡都有可能被破坏，因此每次插入时都要通过旋转来维持平衡二叉树的结构。假设需平衡的结点为 8，那么破坏平衡的情况有四种：
- 左左：对 8 的左儿子的左子树进行一次插入
- 左右：对 8 的左儿子的右子树进行一次插入
- 右左：对 8 的右儿子的左子树进行一次插入
- 右右：对 8 的右儿子的右子树进行一次插入
要解决上述的问题，找到距离新插入结点最近的不平衡子树进行旋转，对于左左情况使用右旋转，右右情况使用左旋转，可以统称为单旋转。左右和右左情况则使用双旋转。左旋转和右旋的旋转方式是互为镜像的，掌握其中一个，另一个自然也会了。左右、右左也是如此
以左左为例讲解单旋转：
-
找到最近的不平衡子树 8
-
创建一个新结点，值等于当前结点的值，即是 8
-
把新结点的右子树设置为当前结点的右子树，即是 9
-
把新结点的左子树设置为当前结点的左子树的右子树，即是 7，到这里得出下面结果
-
再接下来目的就很明确了，将 6 当作根结点，新结点作为 6 的右儿子，这样就完成了一次右旋转，可以想象成 8 向右转了一个角度
双旋转其实就是做两次旋转，对于左右情况，先对 6 做一次左旋转，然后才是 8 做一次右旋转；对于右左情况，先对 8 做一次右旋转，然后才是 5 做一次左旋转
代码实现如下：
public class AVLNode {
int value;
AVLNode left;
AVLNode right;
public AVLNode(int value) {
this.value = value;
}
/**
* 返回当前结点的高度
* @return 当前结点的高度
*/
public int getHeight() {
return Math.max(left == null ? 0 : left.getHeight(),
right == null ? 0 : right.getHeight()) + 1;
}
/**
* 获取左子树的高度
* @return 左子树的高度
*/
public int getLeftHeight() {
if (left == null) {
return 0;
}
return left.getHeight();
}
/**
* 获取右子树的高度
* @return 右子树的高度
*/
public int getRightHeight() {
if (right == null) {
return 0;
}
return right.getHeight();
}
/**
* 向子树添加结点
* @param node 要添加的结点
*/
public void add(AVLNode node) {
if (node != null) {
// 添加的结点比当前结点的值小
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);
}
}
}
// 判断是否平衡
// 进行右旋转
if (getLeftHeight() - getRightHeight() >= 2) {
// 双旋转
if (left != null && left.getLeftHeight() < left.getRightHeight()) {
// 先左旋转
left.leftRotate();
// 再右旋转
rightRotate();
} else {
// 单旋转
rightRotate();
}
}
// 进行左旋转
if(getLeftHeight() - getRightHeight() <= -2) {
if (right != null && right.getRightHeight() < right.getLeftHeight()) {
// 先右旋转
right.rightRotate();
// 再左旋转
leftRotate();
} else {
// 单旋转
leftRotate();
}
}
}
/**
* 左旋转
*/
private void leftRotate() {
AVLNode node = new AVLNode(value);
node.left = left;
node.right = right.left;
value = right.value;
right = right.right;
left = node;
}
/**
* 右旋转
*/
private void rightRotate() {
// 创建一个新结点，值等于当前结点的值
AVLNode node = new AVLNode(value);
// 把新结点的右子树设置为当前结点的右子树
node.right = right;
// 把新结点的左子树设置为当前结点的左子树的右子树
node.left = left.right;
// 把当前结点的值换为左子结点的值
value = left.value;
// 把当前结点的左子树设置为左子树的左子树
left = left.left;
// 把当前结点的右子树设置为新结点
right = node;
}
/**
* 查找结点
* @param value 目标结点的值
* @return 目标结点
*/
public AVLNode search(int value) {
if (this.value == value) {
return this;
} else if (value < this.value) {
if (left == null) {
return null;
}
return left.search(value);
} else {
if (right == null) {
return null;
}
return right.search(value);
}
}
/**
* 查找父结点
* @param value 目标父结点的子结点的值
* @return 目标父结点
*/
public AVLNode searchParent(int value) {
if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
return this;
} else {
if (this.left != null && this.value > value) {
return this.left.searchParent(value);
} else if (this.right != null && this.value < value) {
return this.right.searchParent(value);
} else {
return null;
}
}
}
}
public class AVLTree {
private AVLNode root;
/**
* 向二叉排序树添加结点
* @param node
*/
public void add(AVLNode node) {
if (root == null) {
root = node;
} else {
root.add(node);
}
}
/**
* 查找结点
* @param value 目标结点的值
* @return 目标结点
*/
public AVLNode search(int value) {
if (root == null) {
return null;
} else {
return root.search(value);
}
}
/**
* 删除结点
* @param value 要删除结点的值
*/
public void delete(int value) {
if (root != null) {
// 找到目标结点
AVLNode target = search(value);
if (target != null) {
// 找到目标结点的父结点
AVLNode parent = searchParent(value);
// 要删除的结点是叶子结点
if (target.left == null && target.right == null) {
// 要删除的结点是父结点的左子结点
if (parent.left.value == value) {
parent.left = null;
// 要删除的结点是父结点的右子结点
} else {
parent.right = null;
}
// 要删除的结点有两个子结点
} else if (target.left != null && target.right != null) {
// 删除右子树中值最小的结点，并获取该结点的值
int min = deleteMin(target.right);
// 替换目标结点的值
target.value = min;
// 要删除的结点只有一个子结点
} else {
// 有左子结点
if (target.left != null) {
// 要删除的结点是父结点的左子结点
if (parent.left.value == value) {
// 父结点的左子结点指向目标结点的左子结点
parent.left = target.left;
// 要删除的结点是父结点的右子结点
} else {
// 父结点的右子结点指向目标结点的左子结点
parent.right = target.left;
}
// 有右子结点
} else {
// 要删除的结点是父结点的左子结点
if (parent.left.value == value) {
// 父结点的左子结点指向目标结点的左子结点
parent.left = target.right;
// 要删除的结点是父结点的右子结点
} else {
parent.right = target.right;
}
}
}
}
}
}
/**
* 删除最小值结点
* @param node 目标二叉树的根结点
* @return
*/
public int deleteMin(AVLNode node) {
AVLNode target = node;
while (target.left != null) {
target = target.left;
}
delete(target.value);
return target.value;
}
/**
* 查找父结点
* @param value 目标父结点的子结点的值
* @return 目标父结点
*/
public AVLNode searchParent(int value) {
if (root == null) {
return null;
} else {
return root.searchParent(value);
}
}
}
