Java与数据结构——平衡二叉树（AVL）

二叉排序树存在的问题

给定一个数列{ 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 +
                '}';
    }
}