2. 程式人生 > >AVL樹和平衡二叉樹 平衡因子 右旋轉LL 左旋轉RR LR RL

AVL樹和平衡二叉樹 平衡因子 右旋轉LL 左旋轉RR LR RL

阿新 • • 發佈：2018-12-18

　　前言

　　今天要介紹幾種高階資料結構AVL樹，介紹之前AVL，會先說明平衡二叉樹，並將樹的學習路線進行總結，並介紹維持平衡的方法：右旋轉、左旋轉。

　　一、樹學習路線

　　1、路線總結

　　總結了一下樹的學習路線，如下圖：

　　

　　2、說明

　　上面這個圖要從上往下進行一步一步學習；首先，從二叉樹開始學習，要對樹的一些概念有一些基本瞭解，如樹的左孩子和右孩子等，然後對樹的遍歷方法：先序、中序和後序遍歷都熟練掌握，有精力再把層序遍歷掌握；

　　接下來，大部分的樹，都是在二叉樹的基礎上加了許多特性而形成的，所以二叉樹是基礎，如二叉搜尋樹，任意一個節點都比左子樹大，都比右子樹小，主要用於解決查詢問題，對二分查詢法有一個基本瞭解，還有一個特性，二分搜尋樹的中序遍歷：資料就從從小到大進行排序了。

　　AVL樹，是今天要講的話題，下面會詳細進行講解。

　　紅黑樹應該是大名鼎鼎了，都應該聽過了，之後我會專門介紹。

　　trie樹就不再是二叉樹了，是多叉樹了，之後也會講解。

　　二、平衡二叉樹

　　1、定義

　　平衡二叉樹，首先是二叉樹，並且對於任意一個節點，左子樹和右子樹的高度差不能超過1。

　　2、意義

　　有了二分查詢樹為什麼還要平衡二叉樹呢？這篇對二分查詢樹進行了詳細介紹,並對先序、中序和後序進行了明確說明，可以參考：https://www.cnblogs.com/liudw-0215/p/9835691.html，因為二叉樹有一個弊端就是會退化為連結串列，就是隻有左子樹或右子樹有節點

，這樣查詢效率就會變低了。所以，就需要“平衡”這個概念了。

　　3、平衡因子

　　先畫個圖，進行說明，不是平衡二叉樹，只是為了說明問題，如下圖：

　　

　　說明：如上圖，樹的高度從葉子節點開始，並且葉子節點高度是1；平衡因子就是用左子樹高度減去右子樹高度，例如：4這個節點，左子樹2的高度為1，右子樹沒有則為0，所以4這個節點的平衡因子為1。

　　三、AVL樹

　　1、定義

　　　　AVL樹是自平衡二分搜尋樹，既具有平衡性和二分性。

　　　2、構建AVL樹類

　　　　是在二分搜尋樹的基礎上進行修改並維持“平衡”這個特性的，首先，來看下AVL樹的類，如下：

#ifndef AVLTREE_AVLTREE_H

 
#define AVLTREE_AVLTREE_H

#include <algorithm>
#include <iostream>
#include <vector>

template<typename Key, typename Value>
class AVLTree {
private:
    struct Node {
        Key key;
        Value value;
        Node *left;
        Node *right;
        int height;    //用於標註高度，計算平衡因子

        Node(Key key, Value value) {
            this->key = key;
            this->value = value;
            this->left = this->right = nullptr;
            height = 1;
        }

        Node(Node *node) {
            this->key = node->key;
            this->value = node->value;
            this->left = node->left;
            this->right = node->right;
            this->height = node->height;
        }
    };

    Node *root;
    int size;

public:

    AVLTree() {
        root = nullptr;
        size = 0;
    }

    ~AVLTree() {
        destroy(root);
    }

    int getSize() {
        return size;
    }

    int isEmpty() {
        return size == 0;
    }
    
    int getHeight(Node *node) {    //獲取高度
        if (node == nullptr) {
            return 0;
        }
        return node->height;
    }

    int getBalanceFactor(Node *node) {    //獲取平衡因子
        if (node == nullptr) {
            return 0;
        }
        return getHeight(node->left) - getHeight(node->right);
    }

    bool isBST() {
        std::vector<Key> keys;
        inOrder(root, keys);
        for (int i = 1; i < keys.size(); ++i) {
            if (keys.at(i - 1) < keys.at(i)) {
                return false;
            }
        }
        return true;
    }

    bool isBalanced() {
        return isBalanced(root);
    }

    void add(Key key, Value value) {
        root = add(root, key, value);
    }

    bool contains(Key key) {
        return getNode(root, key) != nullptr;
    }

    Value *get(Key key) {
        Node *node = getNode(root, key);
        return node == nullptr ? nullptr : &(node->value);
    }

    void set(Key key, Value newValue) {
        Node *node = getNode(root, key);
        if (node != nullptr) {
            node->value = newValue;
        }
    }

    // 從二叉樹中刪除鍵值為key的節點
    Value *remove(Key key) {
        Node *node = getNode(root, key);
        if (node != nullptr) {
            root = remove(root, key);
            return &(node->value);
        }
        return nullptr;
    }

private:

    // 向以node為根的二叉搜尋樹中,插入節點(key, value)
    // 返回插入新節點後的二叉搜尋樹的根
    Node *add(Node *node, Key key, Value value) {
        if (node == nullptr) {
            size++;
            return new Node(key, value);
        }
        if (key == node->key) {
            node->value = value;
        } else if (key < node->key) {
            node->left = add(node->left, key, value);
        } else {
            node->right = add(node->right, key, value);
        }
        node->height = 1 + std::max(getHeight(node->left), getHeight(node->right));
        int balanceFactor = getBalanceFactor(node);
        if (std::abs(balanceFactor) > 1) {
            std::cout << "unbalanced : " << balanceFactor;
        }
        return node;
    }

    // 在以node為根的二叉搜尋樹中查詢key所對應的Node
    Node *getNode(Node *node, Key key) {
        if (node == nullptr) {
            return nullptr;
        }
        if (key == node->key) {
            return node;
        } else if (key < node->key) {
            return getNode(node->left, key);
        } else {
            return getNode(node->right, key);
        }
    }

    void destroy(Node *node) {
        if (node != nullptr) {
            destroy(node->left);
            destroy(node->right);
            delete node;
            size--;
        }
    }

    // 在以node為根的二叉搜尋樹中,返回最小鍵值的節點
    Node *minimum(Node *node) {
        if (node->left == nullptr)
            return node;
        return minimum(node->left);
    }

    // 在以node為根的二叉搜尋樹中,返回最大鍵值的節點
    Node *maximum(Node *node) {
        if (node->right == nullptr)
            return node;
        return maximum(node->right);
    }

    // 刪除掉以node為根的二分搜尋樹中的最小節點
    // 返回刪除節點後新的二分搜尋樹的根
    Node *removeMin(Node *node) {
        if (node->left == nullptr) {
            Node *rightNode = node->right;
            delete node;
            size--;
            return rightNode;
        }

        node->left = removeMin(node->left);
        return node;
    }

    // 刪除掉以node為根的二分搜尋樹中的最大節點
    // 返回刪除節點後新的二分搜尋樹的根
    Node *removeMax(Node *node) {
        if (node->right == nullptr) {
            Node *leftNode = node->left;
            delete node;
            size--;
            return leftNode;
        }

        node->right = removeMax(node->right);
        return node;
    }

    // 刪除掉以node為根的二分搜尋樹中鍵值為key的節點
    // 返回刪除節點後新的二分搜尋樹的根
    Node *remove(Node *node, Key key) {
        if (node == nullptr) {
            return nullptr;
        }
        if (key < node->key) {
            node->left = remove(node->left, key);
            return node;
        } else if (key > node->key) {
            node->right = remove(node->right, key);
            return node;
        } else {
            if (node->left == nullptr) {
                Node *rightNode = node->right;
                delete node;
                size--;
                return rightNode;
            }

            if (node->right == nullptr) {
                Node *leftNode = node->left;
                delete node;
                size--;
                return leftNode;
            }

            Node *successor = new Node(minimum(node->right));
            //Node *precursor = new Node(maximum(node->right));
            size++;

            successor->right = removeMin(node->right);
            successor->left = node->left;
            //precursor->left = removeMax(node->left);
            //precursor->right = node->right;

            delete node;
            size--;

            return successor;
            //return precursor;
        }
    }

    void inOrder(Node *node, std::vector<Key> keys) {
        if (node == nullptr) {
            return;
        }
        inOrder(node->left, keys);
        keys.push_back(node->key);
        inOrder(node->right, keys);
    }

    bool isBalanced(Node *node) {
        if (node == nullptr) {
            return true;
        }

        int balanceFactor = getBalanceFactor(node);
        if (std::abs(balanceFactor) > 1) {
            return false;
        }

        return isBalanced(node->left) && isBalanced(node->right);
    }
};

#endif //AVLTREE_AVLTREE_H
View Code

　　增加height屬性，用於記錄每個節點的高度，並計算平衡因子；

　　3、獲取節點高度

　　把height屬性返回就可以了：

int getHeight(Node *node) {    //獲取高度
        if (node == nullptr) {
            return 0;
        }
        return node->height;
    }

　　4、獲取平衡因子

　　將左子樹高度減去右子樹高度即可，但注意：不要區絕對值，因為之後的旋轉要判斷左子樹還是右子樹的高度高，程式碼如下：

int getBalanceFactor(Node *node) {    //獲取平衡因子
        if (node == nullptr) {
            return 0;
        }
        return getHeight(node->left) - getHeight(node->right);
    }

　　5、判斷是不是平衡二叉樹

　　平衡因子大於1就不是平衡二叉樹了，程式碼如下：

bool isBalanced(Node *node) {
        if (node == nullptr) {
            return true;
        }

        int balanceFactor = getBalanceFactor(node);
        if (std::abs(balanceFactor) > 1) {
            return false;
        }

        return isBalanced(node->left) && isBalanced(node->right);
    }

bool isBalanced() {
        return isBalanced(root);
    }

　　四、AVL樹的旋轉

　　　1、什麼時維護平衡？

　　如下圖，假如原來沒有2這個節點，那麼樹是平衡二叉樹，但插入2之後，就不再平衡了，這時就需要維護平衡了，大體上有4種情況需要維護平衡，來說明這一種。

　　　　

　　　　2、右旋轉　LL

 　　　　將其中的部分節點抽離出來，如下圖：

　　

　　說明：主要分為兩步：

　　第一步：將T3儲存，然後將y以及孩子節點旋轉到x的右孩子位置，相對於x，y是順時針向右旋轉的，所以叫右旋轉；

　　第二步：將T3移到y的左孩子位置

　　最後，形成的二叉樹符合二分和平衡兩個性質，所以還是平衡二叉樹。

　　3、右旋轉程式碼實現

　　上圖應該已經講解的很明白了吧，程式碼如下：

Node *rightRotate(Node *y) {
        Node *x = y->left;    //存x
        Node *tmp = x->right;    //將x的右孩子備份
        x->right = y;    //將y右旋轉到x的右孩子
        y->left = tmp;    //將x的右孩子移到y的左側
        y->height = std::max(getHeight(y->left), getHeight(y->right)) + 1;    //修改y高度，注意要先修改y的高度
        x->height = std::max(getHeight(x->left), getHeight(x->right)) + 1;    //修改x的高度
        return x;
    }

　　4、左旋轉 RR

 　　左旋轉和右旋轉很相似，只是方向不同，如下圖：

　　

　　說明：相對於x，y是逆時針向左旋轉，所以是左旋轉

 　　5、左旋轉程式碼實現

　　左旋轉程式碼跟右旋轉很相似，程式碼如下：

Node *leftRotate(Node *y){
        Node *x = y->right;
        Node *tmp = x->left;
        x->left = y;
        y->right = tmp;
        y->height = std::max(getHeight(y->left), getHeight(y->right)) + 1;
        x->height = std::max(getHeight(x->left), getHeight(x->right)) + 1;
        return x;
    }

　　6、LR

　　還有兩種情況需要討論，LL代表“左左”，LR代表“左右”，如下圖：

　　

　　說明：藉助左旋轉將LR轉為LL，再對LL進行右旋轉就OK了，所以理解左、右旋轉是基礎！

　　7、LR程式碼實現

　　程式碼如下：

if (balanceFactor > 1 && getBalanceFactor(node->left) < 0) {    //LR
            node->left = leftRotate(node->left);
            return rightRotate(node);
        }

　　8、RL

　　最後一種情況RL，如下圖：

　　

　　9、RL程式碼實現

　　程式碼如下：

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

　　總結

　　AVL樹和平衡二叉樹就比較難了，主要理解右旋轉和左旋轉，對之後理解紅黑樹有巨大作用！

相關推薦

LeetCode——中級演算法——樹和圖——二叉樹的鋸齒形層序遍歷（JavaScript）

給定一個二叉樹，返回其節點值的鋸齒形層次遍歷。（即先從左往右，再從右往左進行下一層遍歷，以此類推，層與層之間交替進行）。 例如： 給定二叉樹 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回鋸

二叉樹和完全二叉樹一些規律

1、二叉樹具有以下規律：       1）二叉樹高度為i所在的層至多有 個節點       2）高度為k的二叉樹至多有 -1個節點       3）對於任何一棵二叉樹，若度為2的

二叉樹：搜尋二叉樹和完全二叉樹

搜尋二叉樹又叫作二叉樹查詢樹或者二叉排序樹， 所謂搜尋二叉樹是指對於任何一個結點，它的左子樹的所有結點都比這個根結點要小，它的右子樹的所有結點都比這個根結點要大。注意是根結點與左右子樹上所有的結點進行比較而不是僅僅與左右孩子結點進行比較，因此根據這個定義，那麼當按照中序

完美二叉樹, 完全二叉樹和完滿二叉樹

樹在資料結構中佔有非常重要的地位。本文從樹的基本概念入手，給出完美(Perfect)二叉樹，完全(Complete)二叉樹和完滿(Full)二叉樹的區別。如果學習過二叉樹，但是對這三種二叉樹並沒有深入的理解，或者完全被國產資料結構教科書所誤導(只聽說過滿二叉樹和完全二叉樹)的朋友不妨花點時間耐著性子將本文仔細

完全二叉樹和滿二叉樹的區別+完全二叉樹求節點問題

今天覆習了下二叉樹的相關知識，發現很多都忘掉了，所以在此記錄下 滿二叉樹 如圖，顧名思義，滿二叉樹說白了其實就是除了最後一層，所有節點都有兩個孩子， 所以: 假設現在有一棵深度為N的滿二叉樹： 總結點數就是2^N-1（計算公式：

資料結構----完全二叉樹和滿二叉樹以及前序、中序、後序遍歷

一） 滿二叉樹和完全二叉樹 1.滿二叉樹定義： 又叫Full Binary Tree. 除最後一層無任何子節點外，每一層上的所有結點都有兩個子結點（最後一層上的無子結點的結點為葉子結點）。也可以這樣理解，除葉子結點外的所有結點均有兩個子結點。節點數達到最大值

完全二叉樹和滿二叉樹的區別

堆的話一般都是用完全二叉樹來實現的，比如大堆和小堆。一個樹節點的度數就是這個樹節點有多少子節點，和樹的深度意義不同。 依據二叉樹的性質，完全二叉樹和滿二叉樹採用順序儲存比較合適 完全二叉樹是效率很高的資料結構，堆是一種完全二叉樹或者近似完全二叉樹，所以效率極高，像

判斷完全二叉樹和滿二叉樹

（一）判斷完全二叉樹 特點一： 只允許最後一層有空缺結點且空缺在右邊，即葉子結點只能在層次最大的兩層上出現；  特點二： 對任一結點，如果其右子樹的深度為j，則其左子樹的深度必為j或j+1 即度為1的點只有1個或0個  解題思路： 首先一棵空樹是完全二叉樹 利用佇

數據結構 第5章 樹的二叉樹 單元小結（2）遍歷二叉樹和線索二叉樹

進行 深度 bsp iteration oid 基礎 二叉樹 線索 push 概念： 遍歷二叉樹： 遍歷：指按某條搜索路線遍訪每個結點且不重復（又稱周遊）。 遍歷的用途：它是樹結構插入、刪除、修改、查找和排序運算的前提，是二叉樹一切運算的基礎和核心。 時間效率: O

AVL樹和平衡二叉樹 平衡因子 右旋轉LL 左旋轉RR LR RL

　　前言 　　今天要介紹幾種高階資料結構AVL樹，介紹之前AVL，會先說明平衡二叉樹，並將樹的學習路線進行總結，並介紹維持平衡的方法：右旋轉、左旋轉。 　　一、樹學習路線 　　1、路線總結 　　總結了一下樹的學習路線，如下圖： 　　 　　2、說明 　　上面這個圖要從上往下進行一步一步學習；首先，

平衡二叉樹(AVL)的插入和刪除詳解(上)

在電腦科學中，AVL樹是最先發明的自平衡二叉查詢樹。在AVL樹中任何節點的兩個子樹的高度最大差別為1，所以它也被稱為高度平衡樹。查詢、插入和刪除在平均和最壞情況下都是O（log n）。增加和刪除可能需要通過一次或多次樹旋轉來重新平衡這個樹。AVL樹得名於它的發明者G.M.

兩種平衡二叉樹的比較: AVL樹和紅黑樹

 1 好處 及 用途         紅黑樹並不追求“完全平衡”——它只要求部分地達到平衡要求，降低了對旋轉的要求，從而提高了效能。 紅黑樹能夠以O(log2 n) 的時間複雜度進行搜尋、插入、刪除操作。此外，由於它的設計，任何不平衡都會在三次旋轉之內解決。當然，還有一

平衡二叉樹和AVL

1  概述               對於一棵二分搜尋樹，如果我們的資料是順序新增到二分搜尋樹中，它就會退化成一個連結串列。我們如何解決這個問題呢，我們需要在現有的二分搜尋樹的基礎上新增一些機制，使得我們二分搜尋樹能維持平衡二叉樹這樣的一個性質，而AVL就是一種最為經典的

AVL-平衡二叉樹的原理和實現

一、簡介 　　本文將通過圖解和程式碼詳細講解AVL平衡二叉樹的性質及失衡和再平衡的內容。在看本文之前希望大傢俱備二分搜尋樹的相關知識。或移步《二分搜尋樹》瞭解二分搜尋樹。   二、平衡二叉樹 　　前面關於二分搜尋樹的文章，最後分析了在極端情況下，二分搜尋樹會退化為一個連結串列，那為了避免這種

二叉排序樹和平衡二叉樹的關系

fill 樹的高度 == eight font 關系 avl樹 avi 等於 　　二叉排序樹： 二叉排序樹又稱二叉查找樹，亦稱二叉搜索樹。 二叉排序樹或者是一顆空樹，或者是具有下列性質的二叉樹： （1）若左子樹不空，則左子樹上所有結點的值均小於它的根節點的值； （2）若右子

平衡二叉樹AVL樹的實現(c++STL)

pre 根節點 code 先序 blog ltr ons void 過程 #include <iostream> using namespace std; template<class Type> class AVLtree;

平衡二叉樹（AVL）與紅黑樹

數組 條件 節點 avl樹 平衡因子 src 特性 復雜度 關聯數組 一、AVL樹性質1.本身首先是一棵二叉搜索樹。2.帶有平衡條件：每個結點的左右子樹的高度之差的絕對值（平衡因子）最多為1。也就是說，AVL樹，本質上是帶了平衡功能的二叉查找樹（二叉排序樹，二叉搜索樹）。A

數據結構 平衡二叉樹avl c++

歸納 all AI 例子 大於 樹節點 fin 深度 UC 平衡二叉樹：一顆空樹，或者是具有以下性質的二叉樹 左子樹和右子樹都是平衡二叉樹 左子樹和右子樹的深度只差不超過1 把二叉樹節點的平衡因子BF(Balance Factor)定義為該節點的左子樹深度減去右子樹深度

數據結構（三十八）平衡二叉樹（AVL樹）

圖1 建立 滿足 技術分享 factor 這也 絕對值 因此 調整 　　一、平衡二叉樹的定義 　　平衡二叉樹（Self-Balancing Binary Search Tree或Height-Balanced Binary Search Tree），是一種二叉排序樹，其中每

平衡二叉樹(Balanced Binary Tree 或 Height-Balanced Tree)又稱AVL樹

binary strong 但是 inf ++i 平衡二叉樹 data 效率 assert 平衡二叉樹(Balanced Binary Tree 或 Height-Balanced Tree)又稱AVL樹 (a)和(b)都是排序二叉樹，但是查找（b）的93節點就需要查找6