二叉排序树存在的问题
给定一个数列{ 1，2，3，4，5，6 }，要求创建一棵二叉排序树，此时就会发现
（1）左子树全部为空，从形式上看更像一个单链表；
（2）插入数据的速度没有影响；
（3）因为需要依次比较，查询速度明显降低，不能发挥BST的优势；
解决方案：平衡二叉树
（1）平衡二叉树也叫平衡二叉搜索树，又被称为 AVL 树，可以保证查询效率较高；
（2）具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。其常见的实现方法有：红黑树、AVL、替罪羊树、Treap、伸展树等。
（3）平衡二叉树图示：
AVL 树左旋思路：给定数列{ 4，3，6，5，7，8 }，构建 AVL 树，当插入 8 时，发现 rightHeight - leftHeight > 1 ，此时不再是一个 AVL 树，进行左旋处理（降低右子树高度）：
（1）创建一个新的节点 newNode （以 4 这个值创建），newNode.val = this.val；
（2）把新节点的左子树设置成当前节点的左子树，newNode.left = this.left；
（3）把新节点的右子树设置成当前节点的右子树的左子树，newNode.right = this.right.left；
（4）把当前节点的值设置成当前节点右节点的值，this.val = this.right.val；
（5）把当前节点的右子树设置成当前节点右子树的右子树，this.right = this.right.right；
（6）把当前节点的左子树设置为新节点，this.left = newNode。
代码实现：
//左旋转方法
private void leftRotate(){
//1. 创建一个新的节点 newNode （以 4 这个值创建），newNode.val = this.val；
Node newNode = new Node(value);
//2. 把新节点的左子树设置成当前节点的左子树，newNode.left = this.left；
newNode.left = left;
//3. 把新节点的右子树设置成当前节点的右子树的左子树，newNode.right = this.right.left；
newNode.right = right.left;
//4. 把当前节点的值设置成当前节点右节点的值，this.val = this.right.val；
value = right.value;
//5. 把当前节点的右子树设置成当前节点右子树的右子树，this.right = this.right.right；
right = right.right;
//6. 把当前节点的左子树设置为新节点，this.left = newNode
left = newNode;
}AVL 树右旋思路：给定数列{ 10，12，8，9，7，6 }，构建 AVL 树，当插入 6 时，发现 leftHeight - rightHeight > 1 ，此时不再是一个 AVL 树，进行右旋处理（降低左子树高度）：
（1）创建一个新的节点 newNode （以 10 这个值创建），newNode.val = this.val；
（2）把新节点的右子树设置成当前节点的右子树，newNode.right = this.right；
（3）把新节点的左子树设置成当前节点的左子树的右子树，newNode.left = this.left.right；
（4）把当前节点的值设置成当前节点左节点的值，this.val = this.left.val；
（5）把当前节点的左子树设置成当前节点左子树的左子树，this.left = this.left.left；
（6）把当前节点的右子树设置为新节点，this.right = newNode。
代码实现：
//右旋转方法
private void rightRotate(){
//1. 创建一个新的节点 newNode （以 10 这个值创建），newNode.val = this.val
Node newNode = new Node(value);
//2. 把新节点的右子树设置成当前节点的右子树，newNode.right = this.right
newNode.right = right;
//3. 把新节点的左子树设置成当前节点的左子树的右子树，newNode.left = this.left.right
newNode.left = left.right;
//4. 把当前节点的值设置成当前节点左节点的值，this.val = this.left.val
value = left.value;
//5. 把当前节点的左子树设置成当前节点左子树的左子树，this.left = this.left.left
left = left.left;
//6. 把当前节点的右子树设置为新节点，this.right = newNode
right = newNode;
}问题分析
AVL 树双旋思路：
（1）当符合右旋转的条件时：
1.1 如果它的左子树的右子树高度大于左子树的左子树的高度；
1.2 先对当前这个节点的左节点进行左旋操作；
1.3 再对当前节点进行右旋转。
（2）当符合左旋转的条件时：
2.1 如果它的右子树的左子树高度大于右子树的右子树的高度；
2.2 先对当前这个节点的右节点进行右旋操作；
2.3 再对当前节点进行左旋转。
代码实现：
//当添加一个节点后 ，如果（右子树高度 - 左子树高度） > 1，进行左旋操作
if (rightHeight() - leftHeight() > 1){
//如果它的右子树的左子树高度大于它的右子树的高度
if (right != null && left.leftHeight() > left.rightHeight()){
//先对当前这个节点的右节点进行右旋操作
right.rightRotate();;
}
leftRotate();//进行左旋转
return;
}
//当添加一个节点后 ，如果（左子树高度 - 右子树高度） > 1，进行右旋操作
if (leftHeight() - rightHeight() > 1){
//如果它的左子树的右子树高度大于它的左子树的高度
if (left != null && left.rightHeight() > left.leftHeight()){
//先对当前这个节点的左节点进行左旋操作
left.leftRotate();
}
rightRotate();
return;
}AVL 树完整代码：
package avl;
public class AVLTreeDemp {
public static void main(String[] args) {
//int[] arr = { 4, 3, 6, 5, 7, 8 };//测试左旋
//int[] arr = { 10, 12, 8, 9, 7, 6 };//测试右旋
int[] arr = { 10, 11, 7, 6, 8, 9 };//测试双旋
//创建一个AVLTree
AVLTree avlTree = new AVLTree();
//添加节点
for (int i = 0; i < arr.length; i++) {
avlTree.add(new Node(arr[i]));
}
//遍历
System.out.println("AVLTree 中序遍历：");
avlTree.infixOrder();
System.out.println();
/*System.out.println("没有做平衡处理前：");
System.out.println("树的高度应该为：" + avlTree.getRoot().height());//4 4 4
System.out.println("树的左子树的高度应该为：" + avlTree.getRoot().leftHeight());//1 3 1
System.out.println("树的右子树的高度应该为：" + avlTree.getRoot().rightHeight());//3 1 3
*/
System.out.println("做平衡处理后：");
System.out.println("树的高度应该为：" + avlTree.getRoot().height());//3 3 3
System.out.println("树的左子树的高度应该为：" + avlTree.getRoot().leftHeight());//2 2 2
System.out.println("树的右子树的高度应该为：" + avlTree.getRoot().rightHeight());//2 2 2
System.out.println("当前的根节点等于：" + avlTree.getRoot());// 6 10 8
}
}
//创建AVLTree
class AVLTree{
private Node root;
public Node getRoot() {
return root;
}
//添加节点的方法
public void add(Node node){
if (root == null){
root = node;//root为空 则让root指向node
}else {
root.add(node);
}
}
//中序遍历
public void infixOrder(){
if (root != null){
root.infixOrder();
}else {
System.out.println("当前树为空，不能遍历！！");
}
}
//查找要删除的节点
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 传入的节点（当做二叉排序树的当前根节点）
//1.返回以 node 为根节点的二叉排序树的最小节点的值
//2.删除 node 为根节点的二叉排序树的最小节点
public int delRightTreeMin(Node node){
Node temp = node;
//循环查找左节点就能找到最小值
while (temp.left != null){
temp = temp.left;
}
//这时temp指向最小节点
//删除最小节点
delNode(temp.value);
return temp.value;//只是从树结构中删除了temp节点，但是该节点本身还存在，所以可以直接返回
}
//删除节点
public void delNode(int value){
if (root == null){
return;
}else {
//1. 需要先去找到要删除的节点 targetNode
Node targetNode = search(value);
//如果没有找到要删除的节点
if (targetNode == null){
return;
}
//如果发现当前二叉排序树只有一个节点
if (root.left == null && root.right == null){
root = null;
return;
}
//2.找到 targetNode 的父节点 parent
Node parentNode = searchParent(value);
//第一种情况：如果要删除的节点是叶子节点
if (targetNode.left == null && targetNode.right == null){//判断是叶子节点
if (parentNode.left != null && parentNode.left.value == value){
//3.判断要删除的节点是父节点的左子节点
parentNode.left = null;//4.删除节点
}else if(parentNode.right != null && parentNode.right.value == value){
//3.判断要删除的节点是父节点的右子节点
parentNode.right = null;//4.删除节点
}
}else if (targetNode.left != null && targetNode.right != null){
//第三种情况：删除有两颗子树的节点
int minValue = delRightTreeMin(targetNode.right);
targetNode.value = minValue;
}else {//剩下的就是第二种情况，删除只有一颗子树的节点
if (parentNode == null) {//特殊情况：！！如果只有一棵子树的节点是根节点
if (targetNode.left != null){
root = targetNode.left;
}else {
root = targetNode.right;
}
}else{
if (parentNode.left != null) {
//3.如果targetNode是父节点的左子节点
if (targetNode.left != null) {
//4.targetNode 的子节点是左子节点
//5.1 parent.left = targetNode.left;
parentNode.left = targetNode.left;
} else {
//4.targetNode 的子节点是右子节点
//5.2 parent.left = targetNode.right;
parentNode.left = targetNode.right;
}
} else {
//3.如果targetNode是父节点的右子节点
if (targetNode.left != null) {
//4.targetNode 的子节点是左子节点
//6.1 parent.right = targetNode.left;
parentNode.right = targetNode.left;
} else {
//4.targetNode 的子节点是右子节点
//6.2 parent.right = targetNode.right;
parentNode.right = targetNode.right;
}
}
}
}
}
}
}
class Node{
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
//添加节点的方法
//递归地形式添加节点，注意需要满足二叉排序树的要求
public void add(Node node){
if(node == null)
return;
//判断传入的节点的值和当前子树的根节点的值的关系
if (node.value < this.value){
//如果当前节点左子节点为 null
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.rightRotate();;
}
leftRotate();//进行左旋转
return;//加一个节点就完成处理 需要return
}
//当添加一个节点后 ，如果（左子树高度 - 右子树高度） > 1，进行右旋操作
if (leftHeight() - rightHeight() > 1){
//如果它的左子树的右子树高度大于它的左子树的高度
if (left != null && left.rightHeight() > left.leftHeight()){
//先对当前这个节点的左节点进行左旋操作
left.leftRotate();
}
rightRotate();
return;//加一个节点就完成处理 需要return
}
}
//中序遍历
public void infixOrder(){
if (this == null) return;
if (this.left != null) this.left.infixOrder();
System.out.printf(this+" ");
if (this.right != null) this.right.infixOrder();
}
//查找要删除的节点
//value 希望删除的节点的值，如果找到返回该节点，否则返回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);
}
}
//查找要删除节点的父节点
//value 是要删除节点的值，返回的是删除节点的父节点，如果没有就返回 null
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 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;
}
//左旋转方法
private void leftRotate(){
//1. 创建一个新的节点 newNode （以 4 这个值创建），newNode.val = this.val；
Node newNode = new Node(value);
//2. 把新节点的左子树设置成当前节点的左子树，newNode.left = this.left；
newNode.left = left;
//3. 把新节点的右子树设置成当前节点的右子树的左子树，newNode.right = this.right.left；
newNode.right = right.left;
//4. 把当前节点的值设置成当前节点右节点的值，this.val = this.right.val；
value = right.value;
//5. 把当前节点的右子树设置成当前节点右子树的右子树，this.right = this.right.right；
right = right.right;
//6. 把当前节点的左子树设置为新节点，this.left = newNode
left = newNode;
}
//右旋转方法
private void rightRotate(){
//1. 创建一个新的节点 newNode （以 10 这个值创建），newNode.val = this.val
Node newNode = new Node(value);
//2. 把新节点的右子树设置成当前节点的右子树，newNode.right = this.right
newNode.right = right;
//3. 把新节点的左子树设置成当前节点的左子树的右子树，newNode.left = this.left.right
newNode.left = left.right;
//4. 把当前节点的值设置成当前节点左节点的值，this.val = this.left.val
value = left.value;
//5. 把当前节点的左子树设置成当前节点左子树的左子树，this.left = this.left.left
left = left.left;
//6. 把当前节点的右子树设置为新节点，this.right = newNode
right = newNode;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
