平衡二叉樹，B樹

AVL樹（平衡二叉樹）

AVL樹本質上是一顆二叉查找樹，可是它又具備如下特色：

一、   它是一棵空樹或它的左右兩個子樹的高度差的絕對值不超過1

二、   左右兩個子樹都是一棵平衡二叉樹。

AVL樹解決了普通二叉查找樹演化爲線性致使線性查找時間問題

AVL樹平衡的操做主要有：

1、左-左型：作右旋。

2、右-右型：作左旋轉。

3、左-右型：先作左旋，後作右旋。

4、右-左型：先作右旋，再作左旋。

右旋：把左孩子變成父節點，原來的父節點變成左孩子的右孩子，見下圖（左左型）。

              

左旋：把右孩子變成父節點，原來的父節點變成右孩子的左孩子，見下圖（右右型）。

              

下面是右左型的平衡操做

                

實現代碼（沒有編寫測試用例，可能會有一些邊界未處理問題）

public class AVL { public class AVLNode{ int height; AVLNode leftChild; AVLNode rightChild; AVLNode parent; int value; } public int getHeight(AVLNode node) { if (node == null) { return 0; }else { return node.height; } } /** * 左左型不平衡，進行右旋操做 * @param LL_type_node */
    public void R_Rotate(AVLNode LL_type_node) { if (LL_type_node != null) { AVLNode left = LL_type_node.leftChild; // 取出要旋轉節點的左孩子
            AVLNode parent = LL_type_node.parent;  // 取出要旋轉節點的父節點
 LL_type_node.leftChild = left.rightChild; // 左孩子的右孩子變成父節點的左孩子
            left.rightChild.parent = LL_type_node; left.rightChild = LL_type_node; // 左孩子的右節點變爲其原來的父節點 // 更新父節點
            LL_type_node.parent = left; left.parent = parent; // 檢查原來要旋轉節點是其父節點的左孩子仍是右孩子
            if (parent.leftChild == LL_type_node) { parent.leftChild = left; }else if (parent.rightChild == LL_type_node) { parent.rightChild = left; } LL_type_node.height = Math.max(getHeight(LL_type_node.leftChild), getHeight(LL_type_node.rightChild)) + 1; left.height = Math.max(getHeight(left.leftChild), getHeight(left.rightChild)) + 1; parent.height = Math.max(getHeight(parent.leftChild), getHeight(parent.rightChild)) + 1; } } /** * 右右型不平衡，進行左旋操做 * @param LL_type_node */
    public void L_Rotate(AVLNode RR_type_node) { if (RR_type_node != null) { AVLNode right = RR_type_node.leftChild; // 取出要旋轉節點的右孩子
            AVLNode parent = RR_type_node.parent;  // 取出要旋轉節點的父節點
 RR_type_node.rightChild = right.leftChild; // 右孩子的左孩子變成父節點的右孩子
            right.leftChild.parent = RR_type_node; right.leftChild = RR_type_node; // 左孩子的右節點變爲其原來的父節點 // 更新父節點
            RR_type_node.parent = right; right.parent = parent; // 檢查原來要旋轉節點是其父節點的左孩子仍是右孩子
            if (parent.leftChild == RR_type_node) { parent.leftChild = right; }else if (parent.rightChild == RR_type_node) { parent.rightChild = right; } RR_type_node.height = Math.max(getHeight(RR_type_node.leftChild), getHeight(RR_type_node.rightChild)) + 1; right.height = Math.max(getHeight(right.leftChild), getHeight(right.rightChild)) + 1; parent.height = Math.max(getHeight(parent.leftChild), getHeight(parent.rightChild)) + 1; } } /** * 左右型，先左旋，後右旋 * @param LR_type_node */
    public void L_R_Rotate(AVLNode LR_type_node) { if (LR_type_node != null) { L_Rotate(LR_type_node.leftChild); R_Rotate(LR_type_node); } } /** * 左右型，先右旋，後左旋 * @param LR_type_node */
    public void R_L_Rotate(AVLNode RL_type_node) { if (RL_type_node != null) { R_Rotate(RL_type_node.rightChild); L_Rotate(RL_type_node); } } public AVLNode insertAVLTree(AVLNode root, AVLNode toInsert) { AVLNode rtRoot = root; if (toInsert != null) { if (root != null) { if (root.value > toInsert.value) { rtRoot.leftChild = insertAVLTree(root.leftChild, toInsert); //插入後看看是否須要調整
                    if (getHeight(rtRoot.leftChild) - getHeight(rtRoot.rightChild) == 2) { // 左左型，進行右旋
                        if (toInsert.value < rtRoot.leftChild.value) { R_Rotate(rtRoot); }else { // 左右型
 L_R_Rotate(rtRoot); } } }else if (root.value < toInsert.value) { rtRoot.rightChild = insertAVLTree(root.rightChild, toInsert); //插入後看看是否須要調整
                    if (getHeight(rtRoot.rightChild) - getHeight(rtRoot.leftChild) == 2) { // 右右型，進行左旋
                        if (toInsert.value > rtRoot.rightChild.value) { L_Rotate(rtRoot); }else { // 右左型
 R_L_Rotate(rtRoot); } } } }else { rtRoot = toInsert; } } rtRoot.height = Math.max(getHeight(rtRoot.leftChild), getHeight(rtRoot.rightChild)) + 1; return rtRoot; } public void deleteNode(AVLNode root, int value) { if (root != null) { if (value < root.value) { deleteNode(root.leftChild, value); int lh = getHeight(root.leftChild); int rh = getHeight(root.rightChild); if (rh - lh == 2) { if(getHeight(root.rightChild.rightChild) > getHeight(root.rightChild.leftChild)){ // 右右型
 L_Rotate(root); }else{ // 右左型
 R_L_Rotate(root); } } }else if (value > root.value) { deleteNode(root.rightChild, value); int lh = getHeight(root.leftChild); int rh = getHeight(root.rightChild); if (lh - rh == 2) { if(getHeight(root.leftChild.leftChild) > getHeight(root.leftChild.rightChild)){ // 左左型
 R_Rotate(root); }else{ // 左右型
 L_R_Rotate(root); } } }else { AVLNode toDeleteParent = root.parent; if (root.leftChild == null) { /* 要刪除節點的左子樹爲空，那麼該節點能夠直接刪除而不用找後繼節點（由於後繼就是它的右 * 孩子，若是它的右孩子也爲空，那說明它是個葉子節點，可直接刪） */
                    if (root == toDeleteParent.leftChild) { toDeleteParent.leftChild = root.rightChild; if (toDeleteParent.leftChild != null) { toDeleteParent.leftChild.parent = toDeleteParent; } }else { toDeleteParent.rightChild = root.rightChild; if (toDeleteParent.rightChild != null) { toDeleteParent.rightChild.parent = toDeleteParent; } } }else if (root.rightChild == null) { /* 要刪除節點的右子樹爲空，那麼該節點能夠直接刪除而不用找後繼節點（由於後繼就是它的父 * 節點，若是它的左孩子也爲空，那說明它是個葉子節點，可直接刪） */
                    if (root == toDeleteParent.leftChild) { toDeleteParent.leftChild = root.leftChild; if (toDeleteParent.leftChild != null) { toDeleteParent.leftChild.parent = toDeleteParent; } }else { toDeleteParent.rightChild = root.leftChild; if (toDeleteParent.rightChild != null) { toDeleteParent.rightChild.parent = toDeleteParent; } } }else { int next = getHeight(root); root.value = next; // 用後繼代替待刪除節點
                    deleteNode(root.rightChild, next); // 刪除後繼
                    
                    int lh = getHeight(root.leftChild); int rh = getHeight(root.rightChild); if (lh - rh == 2) { if(getHeight(root.leftChild.leftChild) > getHeight(root.leftChild.rightChild)){ // 左左型
 R_Rotate(root); }else{ // 左右型
 L_R_Rotate(root); } } } } root.height = Math.max(getHeight(root.leftChild), getHeight(root.leftChild)) + 1; } } /** * 取得當前節點的後繼 * @param currentNode * @return
     */
    public int getNextNodeValue(AVLNode currentNode) { if ((currentNode = currentNode.rightChild) != null) { while(currentNode.leftChild != null){ currentNode = currentNode.leftChild; } } return currentNode.value; } }

View Code

紅黑樹

紅黑樹是近似平衡的二叉查找樹，它相比AVL樹在調整的時候能夠減小旋轉次數，它具備如下特色

　　一、節點是紅色或黑色。

二、根節點是黑色。

三、每一個紅色節點的兩個子節點都是黑色。(從每一個葉子到根的全部路徑上不能有兩個連續的紅色節點)

四、從任一節點到其每一個葉子的全部路徑都包含相同數目的黑色節點。

這些約束強制了紅黑樹的關鍵性質: 從根到葉子的最長的可能路徑很少於最短的可能路徑的兩倍長。結果是這個樹大體上是平衡的。由於操做好比插入、刪除和查找某個值的最壞狀況時間都要求與樹的高度成比例，這個在高度上的理論上限容許紅黑樹在最壞狀況下都是高效的，而不一樣於普通的二叉查找樹。

紅黑樹的插入刪除過程較爲複雜，詳細請參考如下博客

紅黑樹插入：http://www.javashuo.com/article/p-orraekjs-n.html

紅黑樹刪除：http://www.javashuo.com/article/p-pwmenxbf-gg.html

B樹

一棵m階B樹(balanced tree of order m)是一棵平衡的m路搜索樹。它或者是空樹，或者是知足下列性質的樹：

1、根結點至少有兩個子女；

2、每一個非根節點所包含的關鍵字個數 j 知足：┌m/2┐ - 1 <= j <= m - 1；即每一個節點最多有m棵子樹（至於爲何去m/2的上界，個人理解應該是爲了樹的平衡性質以及樹的高度不會過高）

3、除根結點之外的全部結點（不包括葉子結點）的度數正好是關鍵字總數加1，故內部子樹個數 k 知足：┌m/2┐ <= k <= m ；

4、全部的葉子結點都位於同一層。

下圖是一棵4階B樹（指針域未畫出來），4階指的是某個節點最多有4棵子樹。

B樹節點的插入：往上圖的4階B樹插入關鍵字6。插入6，進入根節點的左子樹，找到合適位置插入，此時關鍵字6所在的節點包含 {5, 6, 8, 9} 共NUM = 4個關鍵字，不知足4階B樹性質（最多有4-1個關鍵字），進行分裂，分裂點爲 NUM / 2向上取整，故在關鍵字6，插入後的結果爲見下圖。插入操做要注意的就是分裂的關鍵字是做爲新的節點，加入其父節點中，而後判斷此時父節點是否須要分裂。

B樹節點的刪除：

相比B樹的插入稍微複雜一些，當從B-樹中刪除一個關鍵字Ki時，總的分爲如下兩種狀況：

若是該關鍵字所在的結點不是最下層的非葉子結點，則先須要把此關鍵字與它在B樹中後繼對換位置，即以指針Pi所指子樹中的最小關鍵字Y代替Ki，而後在相應的結點中刪除Y。

若是該關鍵字所在的結點正好是最下層的非葉子結點，這種狀況下，會有如下兩種可能：

　　一、若該關鍵字Ki所在結點中的關鍵字個數不小於┌m/2┐，則能夠直接從該結點中刪除該關鍵字和相應指針便可。

　　二、若該關鍵字Ki所在結點中的關鍵字個數小於┌m/2┐，則直接從結點中刪除關鍵字會致使此結點中所含關鍵字個數小於┌m/2┐-1 。這種狀況下，需考察該結點在B樹中的左或右兄弟結點，從兄弟結點中移若干個關鍵字到該結點中來（這也涉及它們的雙親結點中的一個關鍵字要做相應變化），使兩個結點中所含關鍵字個數基本相同；但若是其兄弟結點的關鍵字個數也不多，恰好等於┌m/2┐-1 ，這種移動則不能進行，這種情形下，須要把刪除了關鍵字Ki的結點、它的兄弟結點及它們雙親結點中的一個關鍵字合併爲一個結點。能力有限，沒法畫動圖，上面的理論也比較難懂，建議直接在網上找個視頻教程看看了解刪除的過程。

還有一種B樹的變形B+樹，它與B樹的區別在於非葉節點僅做爲索引做用，不保存具體信息，而且全部的葉節點構成一條有序鏈表。它相比B樹的優勢在於一個內存塊能夠存儲更多的關鍵字（由於B+樹只存索引，而B樹還保存着信息，全部B+樹關鍵字佔用內存少），減小了磁盤io，另外因爲全部的葉子節點構成有序鏈表，全部能夠方便的進行範圍查詢。更多詳細請參考：http://www.javashuo.com/article/p-nxtmjxfy-kz.html