平衡二叉树(JAVA)

平衡二叉树(AVL)

前情提要

该平衡二叉树的分析是在 二叉排序树 的基础上进行改造的，平衡二叉树可以对  二叉排序树 可能出现的性能问题进行优化。

 

给定一个数列 {1,2,3,4,5,6} ，要求创建一颗二叉排序树 (BST)，如下图所示：

上图存在的问题分析:

（1）左子树全部为空，从形式上看，更像一个单链表；

（2）插入速度没有影响；

（3）查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢。

解决方案： 平衡二叉树(AVL)

 

1. 平衡二叉数介绍

（1）平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树， 可以保证查询效率较高；

（2）特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树；

（3）常用实现方法：红黑树、AVL算法、替罪羊树、Treap、伸展树等。

（4）举例如下：

2. 平衡二叉数单旋转之左旋转

给定一个数列{4,3,6,5,7,8}，创建出对应的平衡二叉树。

 

问题：rightHight - leftRight > 1成立，所以不再是一个平衡二叉树，此时右子树高度高于左子树的高度。

 

解决：对平衡二叉树进行左旋转。

 

实现逻辑：

 

步骤1：创建一个新节点newNode，把新节点的值设为当前根节点的值，并把新节点的左子树设置为当前根节点的左子树；

 

步骤2：把新节点的右子树设置为当前根节点的右子树的左子树；

 

步骤3：把当前根节点的值替换成根节点的右节点的值；

 

步骤4：把当前根节点的右子树设置为当前根节点的右子树的右子树；

 

步骤5：把当前根节点的左子树设置为新节点。

 

如下图所示：

 

3. 平衡二叉数单旋转之右旋转

给定一个数列{10,12,8,9,7,6}，创建出对应的平衡二叉树。

问题： leftRight - rightHight > 1成立，所以不再是一个平衡二叉树，此时左子树高度高于右子树的高度。

 

解决：对平衡二叉树进行右旋转。

 

实现逻辑：

 

步骤1：创建一个新节点newNode，把新节点的值设为当前根节点的值，并把新节点的右子树设置为当前根节点的右子树；

 

步骤2：把新节点的左子树设置为当前根节点的左子树的右子树；

 

步骤3：把当前根节点的值替换成根节点的左节点的值；

 

步骤4：把当前根节点的左子树设置为当前根节点的左子树的左子树；

 

步骤5：把当前根节点的右子树设置为新节点。

 

如下图所示：

4. 平衡二叉数双旋转

前面的两个数列，进行单旋转 ( 即一次旋转 ) 就可以将非平衡二叉树转成平衡二叉树， 但是在某些情况下，单旋转不能完成平衡二叉树的转换；

 

比如给定数组 int[] arr = { 10, 11, 7, 6, 8, 9 }，通过单旋转中的右旋转， 并没有转成 AVL 树，如下图所示：

实现逻辑（以右旋转为例）：

步骤1：当符合右旋转的条件时，如果当前节点(10)的左子树的右子树高度大于左子树的左子树的高度，先对当前节点的左节点进行左旋转 ；

步骤2：在对当前节点进行右旋转的操作即可。

如下图所示：

 

5.平衡二叉树代码实现

完整的代码实现如下：

public class AvlTreeDemo {

    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.infixOrder();
        System.out.println("在平衡处理后：");
        System.out.println("树的高度=" + avlTree.getRoot().height());
        System.out.println("树的左子树高度=" + avlTree.getRoot().leftHeight());
        System.out.println("树的右子树高度=" + avlTree.getRoot().rightHeight());
        System.out.println("当前的根结点=" + avlTree.getRoot());
    }
}

// 创建二叉排序树
class AvlTree {
    private Node root;

    /**
     * 获取根节点
     *
     * @return 根节点
     */
    public Node getRoot() {
        return root;
    }

    /**
     * 添加结点的方法
     *
     * @param node 需要添加的节点
     */
    public void add(Node node) {
        // 如果 root 为空，则直接让 root 指向 node
        if (root == null) {
            root = node;
        } else { // 调用Node节点的add方法进行添加
            root.add(node);
        }
    }

    /**
     * 中序遍历方法
     */
    public void infixOrder() {
        // root不为空，则进行遍历
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉排序树为空，不能遍历");
        }
    }

    /**
     * 查找要删除的节点
     *
     * @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 value 需要删除节点的值
     */
    public void delNode(int value) {
        if (root == null) {
            return;
        } else {
            // 1.需要先找到要删除的结点 targetNode
            Node targetNode = search(value);
            // 如果没有找到要删除的结点
            if (targetNode == null) {
                return;
            }
            // 2.如果找到了，判断该树是否只有一个节点，如果只有一个，直接赋为null，删除完成
            if (root.left == null && root.right == null) {
                root = null;
                return;
            }
            // 3.去找到 targetNode 的父节点
            Node parent = searchParent(value);
            // 第一种情况：如果要删除的节点是叶子节点
            if (targetNode.left == null && targetNode.right == null) {
                delLeafNode(parent, value);
            } else if (targetNode.left != null && targetNode.right != null) { // 第二种情况：删除有两颗子树的节点
                int minValue = delTwoNode(targetNode.right);
                targetNode.value = minValue; // 将最小值赋值给需要删除的节点
            } else { // 第三种情况：删除只有一颗子树的节点
                delOneNode(targetNode, parent, value);
            }
        }
    }

    /**
     * 删除的节点是叶子节点
     *
     * @param parent 父节点
     * @param value  需要删除的节点的值
     */
    public void delLeafNode(Node parent, int value) {
        // 判断 targetNode 是父结点的左子结点，还是右子结点
        if (parent.left != null && parent.left.value == value) { // 是左子节点
            parent.left = null;
        } else if (parent.right != null && parent.right.value == value) {// 是右子节点
            parent.right = null;
        }
    }

    /**
     * 删除只有一颗子树的节点
     *
     * @param targetNode 需要删除的节点
     * @param parent     父节点
     * @param value      需要删除的节点的值
     */
    public void delOneNode(Node targetNode, Node parent, int value) {
        // 如果要删除的节点有左子节点
        if (targetNode.left != null) {
            // 当只有两个节点的时候，删除最上面的节点，该节点的parent是为空的，会报空指针
            if (parent != null) {
                if (parent.left.value == value) { // targetNode 是 parent 的左子节点
                    parent.left = targetNode.left;
                } else { // targetNode 是 parent 的右子节点
                    parent.right = targetNode.left;
                }
            } else { // 如果父节点为空，则只需要将root指向当前节点的left即可
                root = targetNode.left;
            }
        } else { // 如果要删除的结点有右子节点
            if (parent != null) {
                if (parent.left.value == value) { // 如果 targetNode 是 parent 的左子节点
                    parent.left = targetNode.right;
                } else { // targetNode 是 parent 的右子节点
                    parent.right = targetNode.right;
                }
            } else { // 如果父节点为空，则只需要将root指向当前节点的right即可
                root = targetNode.right;
            }
        }
    }

    /**
     * 删除有两颗子树的节点
     *
     * @param node 需要删除的节点的右子树（当做二叉排序树的根结点)）
     * @return 返回的 以 node 为根结点的二叉排序树的最小结点的值
     */
    public int delTwoNode(Node node) {
        Node targetNode = node;
        // 循环的查找左子节点，最后一个左子节点就是最小值
        if (targetNode.left != null) {
            targetNode = targetNode.left;
        }
        // 删除最小结点
        delNode(targetNode.value);
        return targetNode.value;
    }

}

// 创建 Node 结点
class Node {

    int value;  // 该节点的值
    Node left;  // 该节点的左子树
    Node right; // 该节点的右子树

    public Node(int value) {
        this.value = value;
    }

    //###################平衡二叉树新增方法start

    /**
     * 返回左子树的高度
     *
     * @return 左子树的高度
     */
    public int leftHeight() {
        if (left == null) {
            return 0;
        }
        return left.height();
    }

    /**
     * 返回右子树的高度
     *
     * @return 右子树的高度
     */
    public int rightHeight() {
        if (right == null) {
            return 0;
        }
        return right.height();
    }

    /**
     * 返回 以该结点为根结点的树的高度
     *
     * @return 树的高度
     */
    public int height() {
        return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
    }

    /**
     * 左旋转方法
     */
    private void leftRotate() {
        // 1.创建新的节点，以当前根节点的值，并把新的节点的左子树设置成当前节点的左子树
        Node newNode = new Node(value);
        newNode.left = left;
        // 2.把新的节点的右子树设置成当前节点的右子树的左子树
        newNode.right = right.left;
        // 3.把当前结点的值替换成右子节点的值
        value = right.value;
        // 4.把当前节点的右子树设置成当前节点右子树的右子树
        right = right.right;
        // 5.把当前节点的左子树(左子结点)设置成新的节点
        left = newNode;
    }

    /**
     * 右旋转方法
     */
    private void rightRotate() {
        // 1.创建新的节点，以当前根节点的值，并把新的节点的右子树设置成当前节点的右子树
        Node newNode = new Node(value);
        newNode.right = right;
        // 2.把新的节点的左子树设置成当前节点的左子树的左子树
        newNode.left = left.right;
        // 3.把当前结点的值替换成左子节点的值
        value = left.value;
        // 4.把当前节点的左子树设置成当前节点左子树的左子树
        left = left.left;
        // 5.把当前节点的右子树(右子结点)设置成新的节点
        right = newNode;
    }
    //###################平衡二叉树新增方法end

    /**
     * 添加结点的方法（递归的形式添加结点，注意需要满足二叉排序树的要求）
     *
     * @param node 需要添加的节点
     */
    public void add(Node node) {
        // 传入的参数为null，则直接结束添加
        if (node == null) {
            return;
        }
        // 判断传入的结点的值，和当前子树的根结点的值的大小关系
        if (node.value < this.value) {
            // 如果当前结点左子结点为 null，则直接添加到当前节点下
            if (this.left == null) {
                this.left = node;
            } else { // 否则继续递归左子树进行添加
                this.left.add(node);
            }
        } else { // 添加的结点的值大于 当前结点的值
            // 如果当前结点右子结点为 null，则直接添加到当前节点下
            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; // 必须要!!!一旦旋转完毕后，酒不需要再进行下面的判断，以防出现预料外的错误
        }
        // 当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
        if (leftHeight() - rightHeight() > 1) {
            // 如果它的 左子树的右子树的高度 大于它的 左子树的左子树的高度，则先对左子树进行左旋转
            if (left != null && left.rightHeight() > left.leftHeight()) {
                left.leftRotate();
            }
            rightRotate(); // 右旋转
        }

    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        if (this.left != null) {
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    /**
     * 查找要删除的 targetNode
     *
     * @param value 需要删除的节点的值
     * @return 如果找到返回该节点，否则返回 null
     */
    public Node search(int value) {
        if (value == this.value) {   // 找到就是该节点，直接返回this
            return this;
        } else if (value < this.value) { // 如果查找的值小于当前节点，向左子树递归查找
            if (this.left == null) { // 如果左子结点为空，直接返回null
                return null;
            }
            return this.left.search(value);
        } else { // 如果查找的值不小于当前节点，向右子树递归查找
            if (this.right == null) { // 如果右子结点为空，直接返回null
                return null;
            }
            return this.right.search(value);
        }
    }

    /**
     * 查找要删除节点的 parent
     *
     * @param value 需要删除的节点的值
     * @return 返回的是要删除的节点的父结点，如果没有找到返回 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; // 没有找到父结点
            }
        }
    }

    @Override
    public String toString() {
        return "Node{" + "value=" + value + '}';
    }
}

 

6. 平衡二叉数小结

（1）不管是单旋转还是在双旋转，旋转都是在树创建完成后再进行判断是否需要；

（2）在执行旋转逻辑的时候，左旋转或者右旋转只能执行其中一种。