數據結構-AVL(自平衡二叉查找樹)插入和刪除的實現

一. AVL的作用

爲什麼使用AVL?

在使用二分搜索樹的時候，在極端的情況下，會退化成鏈表。如下圖

二. AVL的特點

對於任意一個節點，左子樹和右子樹的高度差不能超過1。
高度和節點數量之間的關係也是O(logn)的。
加入/刪除節點後，沿着節點維護平衡性。

三. 如何維護AVL的平衡

1. 添加如何維護平衡（4種情景）

情景1 ：左子樹的左節點上（LL）: 右旋轉。

右旋轉僞代碼：

//右旋轉
//        y                              x
//     /    \                         /    \
//    x     T4   向右選擇（y）         z      y
//   / \             ---->          /  \    / \
//  z  T3                           1  T2  T3 T4
// / \
//T1 T2
// T1 < z < T2 < x < T3 < y < T4
private Node rightRotate(Node y) {
    Node x = y.left;
    Node T3 = x.right;
    //向右旋轉
    x.right = y;
    y.left = T3;
    //更新height
    y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
    x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
    //返回新的根節點
    return x;
}

情景2 ：右子樹的右節點上（RR）：左旋轉

左旋轉僞代碼：

 //左旋轉
    //        y                              x
    //     /    \                         /    \
    //    T1     x        向左選擇（y）    y      z
    //          / \      ---->          /  \    / \
    //         T2  z                    T1  T2 T3 T4
    //            / \
    //           T3 T4
    // T1 < y < T2 < x < T3 < z < T4
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T2 = x.left;
        //向左旋轉
        x.left = y;
        y.right = T2;
        //更新height
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        //返回新的根節點
        return x;
    }

情景3 ：左子樹的右節點上（LR）：左子節點左旋轉，然後右旋轉

情景4 ：右子樹的左節點上（RL）：右子節點右旋轉，然後左旋轉

2. 刪除如何維護平衡？

刪除以10爲根節點的元素9.返回新的根節點。

邏輯
1 ：判斷根節點是否爲null,如果爲null，返回null。
2：判斷待刪除的節點和根節點比較，如果比根節點小，就從根節點的左子樹中刪除，返回原來的根節點。
node.left = remove(node.left,key).遞歸調用。
如果比根節點大，就從右子樹中刪除，返回原來的根節點。
node.right = remove(node.right,key),遞歸調用。
如果和根節點相同，則刪除根節點，刪除根節點：首先判斷左子樹是否爲空，如果爲空，則新的根節點爲原來根節點的右子樹。
if(node.left ==null){
Node rightNode = node.right;
node.right = null;
size–;
retNode = rightNode;
}
如果右子樹爲空，則新的根節點爲原來根節點的左子樹。
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size–;
retNode = leftNode;
}
如果左右子樹都不爲空，則查詢出右子樹中最小的元素作爲新的根節點。然後刪除右子樹的最小根節點，最後保持之前樹的結構
Node successor = minimum(node.right)；
successor.right = remove(mode.right,key);
successor.left = node.left;
node.left = mode.right = null;
retNode = successor;

以上的刪除的操作，下面是維護平衡的操作。
3: 返回刪除後的根節點是否爲null，如果爲null,返回null.
4: 更新返回根節點的高度，然後計算平衡因子，判斷高度差是否大於1。如果大於1，則維護平衡。
四種情況：1.如果左H-右H > 1 且左子樹的平衡因子>=0,即LL,右旋。
2.如果右H-左H > 1 且右子樹的平衡因子<=0,即RR,左旋。
3. 如果右H-左H > 1 ，RL，先右旋變成RR,然後左旋。
4.如果左H-右H >1 ,LR，先左旋，變成LL,然後右旋。
返回待刪除的節點。

刪除的僞代碼如下：

/**
 * 刪除以Node爲根節點的key ,返回新根節點
 *
 * @param node
 * @param key
 * @return
 */
private Node remove(Node node, K key) {
    if (node == null) {
        return null;
    }
    //返回的節點
    Node retNode;
    if (key.compareTo(node.key) < 0) {
        node.left = remove(node.left, key);
        //返回原來的根節點
        retNode = node;
    } else if (key.compareTo(node.key) > 0) {
        node.right = remove(node.right, key);
        //返回原來的根節點
        retNode = node;
    } else {
        //待刪除節點左子樹爲空的情況
        if (node.left == null) {
            Node rightNode = node.right;
            //指向空
            node.right = null;
            size--;
            retNode = rightNode;
        }
        //待刪除節點右子樹爲空的情況
        else if (node.right == null) {
            Node leftNode = node.left;
            //指向空
            node.left = null;
            size--;
            retNode = leftNode;
        } else {
            //都不爲空的情況下
            //找到比待刪除節點大的最小節點，即待刪節點右子樹的最小節點
            //用這個節點頂替待刪除節點的位置
            Node successor = minimum(node.right);
            //移除的時候維護平衡
            successor.right = remove(node.right, successor.key);
            successor.left = node.left;
            node.left = node.right = null;
            retNode = successor;
        }
    }

    //刪除後的根爲空
    if (retNode == null) {
        return null;
    }
    //更新height 左子樹的高度和右子樹最大的+1
    retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
    //計算平衡因子
    int balanceFactor = getBalanceFactor(retNode);
    //平衡二叉樹
    if (Math.abs(balanceFactor) > 1) {
        System.out.println("unbalanced: " + balanceFactor);
        //維護平衡性
    }

    //平衡維護   左子樹的高度大於等於右子樹的高度 向左傾斜 LL
    if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {
        //右旋轉
        return rightRotate(retNode);
    }

    //平衡維護   左子樹的高度大於等於右子樹的高度 向左傾斜 RR
    if (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0) {
        //左旋轉
        return leftRotate(retNode);
    }
    //平衡維護 LR
    if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
        retNode.left = leftRotate(retNode.left);
        return rightRotate(retNode);
    }

    //平衡維護 RL
    if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {
        retNode.right = rightRotate(retNode.right);
        return leftRotate(retNode);
    }

    return retNode;
}

四. 時間複雜度分析

刪除 O(logN)
插入O(logN)
查詢O(logN)

五. Java代碼的簡單實現

import java.util.ArrayList;

/**
 * 平衡二叉樹 ：對於任意一個節點，左子樹和右子樹的高度差不能超過1.
 * 平衡二叉樹的高度和節點數量之間的關係也是O(logn)的。
 * 標註節點的高度
 * 計算平衡因子： 左右子樹的高度差 大於1的就不是平衡二叉樹
 * <p>
 * 下面是按照二分搜索樹 實現的AVL
 * <p>
 * 在加入節點後，沿着節點向上維護平衡性
 * <p>
 * AVL樹的左旋轉和右旋轉
 * LL 左子樹的左側 右旋轉
 * RR 右子樹的右側 左旋轉
 * LR Y左子樹的右側 左子樹X的根節點左旋轉變成了LL的情況，在對Y進行右旋轉。
 * RL Y右子樹的左側 右子樹X的根節點右旋轉變成了RR的情況，在對Y進行左旋轉。
 * <p>
 * AVL的刪除 依然考慮到什麼時候維護平衡。
 * <p>
 * 更多AVL樹的相關問題
 * <p>
 * AVL的優化 -> 維護平衡 高度和之前一樣，就不需要去維護了
 * AVL樹的侷限性：紅黑樹的平均性能比AVL好些。都是O(logN)
 * 維護不平衡的二分搜索樹
 *
 * @author 一直往前走
 * @date 2020/03/25
 */
public class AVLTree<K extends Comparable<K>, V> {

    private class Node {
        public K key;
        public V value;
        public Node left, right;
        public int height;//當前節點的高度

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            this.left = null;
            this.right = null;
            this.height = 1;//新的節點高度都是1 就是葉子節點的高度。
        }
    }

    private Node root;

    private int size;

    public AVLTree() {
        root = null;
        size = 0;
    }

    //獲得節點的高度
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }


    /**
     * 向二分搜索樹添加新的元素（key,value)
     *
     * @param key
     * @param value
     */
    public void add(K key, V value) {
        root = add(root, key, value);
    }

    /**
     * 平衡二叉樹的添加節點
     *
     * @param node
     * @param key
     * @param value
     * @return
     */
    private Node add(Node node, K key, V value) {
        if (node == null) {
            size++;
            return new Node(key, value);
        }
        if (key.compareTo(node.key) < 0) {
            node.left = add(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = add(node.right, key, value);
        } else {
            node.value = value;
        }
        //更新height 左子樹的高度和右子樹最大的+1
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
        //計算平衡因子 節點node 左右子樹的高度查
        int balanceFactor = getBalanceFactor(node);
        //平衡二叉樹
        if (Math.abs(balanceFactor) > 1) {
            System.out.println("unbalanced: " + balanceFactor);
            //維護平衡性
        }

        //平衡維護   左子樹的高度大於等於右子樹的高度 向左傾斜 LL
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
            //右旋轉
            return rightRotate(node);
        }

        //平衡維護   左子樹的高度大於等於右子樹的高度 向左傾斜 RR
        if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
            //左旋轉
            return leftRotate(node);
        }
        //平衡維護 LR
        if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }

        //平衡維護 RL
        if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }

        return node;
    }

    //右旋轉
    //        y                              x
    //     /    \                         /    \
    //    x     T4   向右選擇（y）         z      y
    //   / \             ---->          /  \    / \
    //  z  T3                           1  T2  T3 T4
    // / \
    //T1 T2
    // T1 < z < T2 < x < T3 < y < T4
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T3 = x.right;
        //向右旋轉
        x.right = y;
        y.left = T3;
        //更新height
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        //返回新的根節點
        return x;
    }


    //左旋轉
    //        y                              x
    //     /    \                         /    \
    //    T1     x        向左選擇（y）    y      z
    //          / \      ---->          /  \    / \
    //         T2  z                    T1  T2 T3 T4
    //            / \
    //           T3 T4
    // T1 < y < T2 < x < T3 < z < T4
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T2 = x.left;
        //向左旋轉
        x.left = y;
        y.right = T2;
        //更新height
        y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
        //返回新的根節點
        return x;
    }

    //獲得節點Node的平衡因子
    private int getBalanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    //判斷該二叉樹是否是一棵二分搜索樹
    public boolean isBST() {
        ArrayList<K> keys = new ArrayList<>();
        inOrder(root, keys);
        for (int i = 1; i < keys.size(); i++) {
            if (keys.get(i - 1).compareTo(keys.get(i)) > 0) {
                return false;
            }
        }
        return true;
    }

    //判斷是否是一棵平衡二叉樹
    public boolean isBalanced() {
        return isBalanced(root);
    }

    //判斷以Node爲根的二叉樹是否是一棵平衡二叉樹，遞歸算法
    public boolean isBalanced(Node node) {
        //節點爲空，肯定是平衡的
        if (node == null) {
            return true;
        }
        //平衡因子
        int balancedFactor = getBalanceFactor(node);
        //平衡因子絕對值不能大於1
        if (Math.abs(balancedFactor) > 1) {
            return false;
        }
        //左子樹和右子樹是否都是平衡二叉樹
        return isBalanced(node.left) && isBalanced(node.right);
    }


    private void inOrder(Node node, ArrayList<K> keys) {
        if (node == null) {
            return;
        }
        //中序便利
        inOrder(node.left, keys);
        keys.add(node.key);
        inOrder(node.right, keys);
    }

    /**
     * 返回以node爲根節點的二分搜索樹中，key所在的節點
     *
     * @param node
     * @param key
     * @return
     */
    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }

        if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else {
            return getNode(node.right, key);
        }
    }

    /**
     * 刪除以Node爲根節點的key ,返回新根節點
     *
     * @param node
     * @param key
     * @return
     */
    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }
        //返回的節點
        Node retNode;
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            //返回原來的根節點
            retNode = node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            //返回原來的根節點
            retNode = node;
        } else {
            //待刪除節點左子樹爲空的情況
            if (node.left == null) {
                Node rightNode = node.right;
                //指向空
                node.right = null;
                size--;
                retNode = rightNode;
            }
            //待刪除節點右子樹爲空的情況
            else if (node.right == null) {
                Node leftNode = node.left;
                //指向空
                node.left = null;
                size--;
                retNode = leftNode;
            } else {
                //都不爲空的情況下
                //找到比待刪除節點大的最小節點，即待刪節點右子樹的最小節點
                //用這個節點頂替待刪除節點的位置
                Node successor = minimum(node.right);
                //移除的時候維護平衡
                successor.right = remove(node.right, successor.key);
                successor.left = node.left;
                node.left = node.right = null;
                retNode = successor;
            }
        }

        //刪除後的根爲空
        if (retNode == null) {
            return null;
        }
        //更新height 左子樹的高度和右子樹最大的+1
        retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
        //計算平衡因子
        int balanceFactor = getBalanceFactor(retNode);
        //平衡二叉樹
        if (Math.abs(balanceFactor) > 1) {
            System.out.println("unbalanced: " + balanceFactor);
            //維護平衡性
        }

        //平衡維護   左子樹的高度大於等於右子樹的高度 向左傾斜 LL
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {
            //右旋轉
            return rightRotate(retNode);
        }

        //平衡維護   左子樹的高度大於等於右子樹的高度 向左傾斜 RR
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0) {
            //左旋轉
            return leftRotate(retNode);
        }
        //平衡維護 LR
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
            retNode.left = leftRotate(retNode.left);
            return rightRotate(retNode);
        }

        //平衡維護 RL
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {
            retNode.right = rightRotate(retNode.right);
            return leftRotate(retNode);
        }

        return retNode;
    }

    /**
     * 刪除以node爲根的二分搜索樹
     * 返回二分搜索樹的根
     * 添加平衡維護 或者
     *
     * @param node
     * @return
     */
    private Node removeMin(Node node) {
        //如果左節點爲null,原根的右節點作爲根節點。
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }


    public V remove(K key) {
        //todo 仿照BST  自己寫
        return null;
    }

    public boolean contains(K key) {
        return getNode(root, key) != null;
    }

    public V get(K key) {
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    public void set(K key, V newValue) {
        AVLTree.Node node = getNode(root, key);
        if (node == null) {
            throw new IllegalArgumentException(key + "doesn't exist~");
        }
        node.value = newValue;
    }


    /**
     * 查找二分查找樹的最小元素
     *
     * @return
     */
    public V minimum() {
        if (size == 0) {
            throw new IllegalArgumentException("BST is empty!");
        }
        return minimum(root).value;
    }

    /**
     * 最小值以node爲根的二分搜索樹
     *
     * @param node
     * @return
     */
    private Node minimum(AVLTree.Node node) {
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }

    /**
     * 查找二分查找樹的最大元素
     *
     * @return
     */
    public V maximum() {
        if (size == 0) {
            throw new IllegalArgumentException("BST is empty!");
        }
        return maximum(root).value;
    }

    /**
     * 最大值以node爲根的二分搜索樹
     *
     * @param node
     * @return
     */
    private Node maximum(AVLTree.Node node) {
        if (node.right == null) {
            return node;
        }
        return minimum(node.right);
    }


    public int getSize() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public static void main(String[] args) {

    }
}

數據結構-AVL(自平衡二叉查找樹)插入和刪除的實現

一. AVL的作用

爲什麼使用AVL?

二. AVL的特點

三. 如何維護AVL的平衡

1. 添加如何維護平衡（4種情景）

情景1 ：左子樹的左節點上（LL）: 右旋轉。

情景2 ：右子樹的右節點上（RR）：左旋轉

情景3 ：左子樹的右節點上（LR）：左子節點左旋轉，然後右旋轉

情景4 ：右子樹的左節點上（RL）：右子節點右旋轉，然後左旋轉

2. 刪除如何維護平衡？

四. 時間複雜度分析

五. Java代碼的簡單實現

linux安裝cuda和cudnn

模擬手機設備：使用 Playwright 實現移動端自動化測試

Mellanox網卡開啓SR-IOV

全面系統的AI學習路徑，幫助普通人也能玩轉AI

uni-app實現上拉加載

vue3編譯優化之“靜態提升”

又是一個月-20240513

flask 如何保證返回json有序

linux服務器設置ssh免密

HTML 00 Tutorial

多線程之深入理解線程池執行器ThreadPoolExecutor

數據結構-二分搜索樹

創建線程的三種方式-繼承Thread,實現Runnable以及實現Callable

Java基礎——代理（靜態代理、JDK動態代理、Cglib動態代理）

深入理解JVM(一)——JVM之內存模型(JMM）JDK1.7

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

數據結構-AVL(自平衡二叉查找樹)插入和刪除的實現

一. AVL的作用

爲什麼使用AVL?

二. AVL的特點

三. 如何維護AVL的平衡

1. 添加 如何維護平衡（4種情景）

情景1 ： 左子樹的左節點上（LL）: 右旋轉。

情景2 ： 右子樹的右節點上（RR）：左旋轉

情景3 ： 左子樹的右節點上（LR）：左子節點 左旋轉， 然後右旋轉

情景4 ： 右子樹的左節點上（RL）：右子節點 右旋轉， 然後左旋轉

2. 刪除如何維護平衡？

四. 時間複雜度分析

五. Java代碼的簡單實現

1. 添加如何維護平衡（4種情景）

情景1 ：左子樹的左節點上（LL）: 右旋轉。

情景2 ：右子樹的右節點上（RR）：左旋轉

情景3 ：左子樹的右節點上（LR）：左子節點左旋轉，然後右旋轉

情景4 ：右子樹的左節點上（RL）：右子節點右旋轉，然後左旋轉