二叉搜索樹以及對二叉搜索樹平衡調整

代碼的思想和圖片參考：好大學慕課浙江大學陳越、何欽銘的《數據結構》

 

我們首先介紹一下什么是二叉搜索樹和二叉平衡樹：

二叉搜索樹：一棵二叉樹，可以為空；如果不為空，滿足以下性質
1. 非空左子樹的所有鍵值小於其根結點的鍵值。
2. 非空右子樹的所有鍵值大於其根結點的鍵值。
3. 左、右子樹都是二叉搜索樹。

二叉搜索樹操作的特別函數：
Position Find( ElementType X, BinTree BST )：從二叉搜索樹BST
中查找元素X，返回其所在結點的地址,查找的次數取決於樹的高度
    算法思想：
    和二分查找類似，如果大於根元素往右邊找，小於根元素網左邊找，可以使用遞歸和非遞歸的方法實現
        注:對尾遞歸，可以用循環來實現。

Position FindMin( BinTree BST )：從二叉搜索樹BST中查找並返回
最小元素所在結點的地址
    算法思想:最小的元素在二叉搜索樹的最左分支的端節點上。一直向左進行遞歸查找即可

Position FindMax( BinTree BST ) ：從二叉搜索樹BST中查找並返回
最大元素所在結點的地址
    算法思想：最小的元素在二叉搜索樹的最右分支的端節點上。一直向右進行遞歸查找即可

BinTree Insert( ElementType X, BinTree BST )
    算法思想：和Find的方法差不多，先找到需要插入的位置，然后進行插入
BinTree Delete( ElementType X, BinTree BST )
    算法思想：分為三種情況
        1.刪除的節點是葉子節點：直接刪除
        2.刪除的節點只有一個孩子:刪除該節點，把該節點的唯一的子節點掛到父節點上
        3.該節點是有兩個孩子的父節點：我們可以把兩個孩子的節點看做是有一個孩子的父節點，但是必須從其子節點找到元素來
        替換他，下面是找元素替換的方法。
            3.1查找該節點左子樹的最大元素，把最大元素的值給該節點，然后把那個左子樹最大元素的節點刪除
            3.2查找該節點右子樹的最小元素，把最小元素的值給該節點，然后把那個右子樹最小元素的節點刪除

            為什么需要找最大或者最小元素呢，因為這樣可以最大或者最小元素可以保證該節點只有一個子節點或者沒有節點
            否則找到一個具有兩個節點的父節點，問題還是沒有解決。
        



    
平衡二叉樹:對於二叉搜索樹來說，搜索的次數取決於樹的高度，那么，由於元素的插入順序和規則的不同
    那么所生成樹的形狀和高度也不相同。可以參考講義的十二個月份按照不同規則插入，造成二叉搜索樹的高度差異有很大
    我們希望樹比較平衡，這樣平均查找次數就比較少
    
    定義:
    平衡因子(Balance Factor,簡稱BF):BF(T)=hl-hr,
    hl和hr為左右子樹的高度
    
    平衡二叉樹的定義(Balance Binary tree 或者稱為AVL樹):
        1.空樹
        2.任意節點左右子樹的高度差不超過1，即|BF|<=1

    那么我們需要思考，n個節點的平衡二叉樹的高度為多少呢？能不能滿足我們的需求呢。
    我可以找規律，我們指定只有一個節點時，高度為0，那么就有如下規律
        平衡二叉樹的高度    平衡二叉樹需要的最少節點個數
            0            1        A
            1            2
            2            4
            ...            ...
            
    具體的規律和證明參考講義，最終我們得到一個結論：給定節點為N的AVL樹的最大高度為O(Log2 N)


    平衡二叉樹的調整問題：
    為什么需要調整平衡兒茶樹呢？因為我們隊平衡二叉樹的插入和刪除操作，可能會破壞
    樹的平衡性，所以我們需要對樹的平衡性進行調整。

 

 

平衡二叉樹的調整圖文解析

注：數字代表平衡因子

平衡二叉樹的調整

注：數字代表平衡因子

1 RR調整

調整的演示圖

 

 

上面的不平衡的搜索樹的發現者是Mar，麻煩節點是Nov，Nov在發現者的右子樹的右邊，因而叫做RR插入，需要進行RR旋轉(右單旋)

 

下面給出RR調整的通用的圖解：

 

 

 

 

2 LL調整

 

 LL調整的演示圖：

 

發現者Mar，麻煩節點為Apr在發現者的左子樹的左邊，因而叫LL插入，需要LL旋轉

 

下面是LL調整的通解圖：

 

 

 

3 LR調整

LR調整的演示圖

 

 

發現節點是May，麻煩節點是Jan，Jan在May左子樹的右子樹中，因而叫做LR插入，需要進行LR旋轉

 

LR調整的通解圖：

 

 

 

4 RL調整

RL調整的演示圖：

 

發現節點是Aug，麻煩節點是Feb，Feb在Aug的右子樹的左子樹上面，因而叫做RL插入，需要進行RL旋轉

 

RL調整的通解圖：

 

 

 

 

 

 

下面是二叉搜索樹的相關操作的代碼：

#include<stdio.h>
#include<stdlib.h>

typedef int elementType;

/*define a binary tree*/
typedef struct node{
    elementType element;
    struct node *left;
    struct node *right;
    int treeHeight;/*為了平衡二叉樹計算方便，定義樹高*/
}tre,*pTree;

/*二叉搜索樹的遞歸查找*/
pTree find(elementType element,pTree tree){
    if(!tree){
        return NULL;
    }
    if(element<tree->element){
        /*查找元素比根元素小在左子樹中查找*/
        return  find(element,tree->left);
    }else if(element>tree->element){
        /*查找元素比根元素小在右子樹中查找*/
        return find(element,tree->right);
    }else{/*找到該節點，返回*/
        return tree;
    }
}

/*因為遞歸方法執行的效率低，而且上面的尾遞歸函數可以改寫為遞歸函數*/
pTree find2(elementType element,pTree tree){
    pTree temp;
    temp = tree;
    while(temp){
        if(element<temp->element){
            temp=temp->left;
        }else if(element>temp->element){
            temp=temp->right;
        }else{
            return temp;
        }
    }
    return NULL;
}

/*根據二叉搜索樹的特點，最小元素在最左邊的節點上面*/
pTree getMinElement(pTree tree){
    if(tree){
         while(tree->left){
            tree=tree->left;
         }
    }

    return tree;
}

/*獲取二叉搜索樹中的最大元素，最大元素的位置應該在最右邊的節點上*/
pTree getMaxElement(pTree tree){
    if(tree){
        while(tree->right){
            tree = tree->right;
        }
    }

    return tree;
}

/*二叉搜索樹的插入，知識遵循二叉搜索樹的性質，但是並沒有調節平衡*/
pTree insert(pTree tree,elementType element){
    pTree temp;
    if(!tree){
        tree = (pTree)malloc(sizeof(tre));
        tree->element=element;
        tree->left=tree->right=NULL;
    }else{/**/
        if(element<tree->element){
            tree ->left = insert(tree->left,element);
        }
        else if(element>tree->element){
            tree->right = insert(tree->right,element);
        }
    }
    return tree;
}

/*非遞歸的二叉搜索樹的算法*/
pTree insert2(pTree tree,elementType element){
    pTree temp;
    int flag;
    pTree parent;
    if(!tree){
        tree = (pTree)malloc(sizeof(tre));
        tree->element=element;
        tree->left=tree->right=NULL;
    }else{
        temp=tree;
        while(temp!=NULL){
            if(element<temp->element){
                //printf("lala\n");
                parent = temp;
                temp=temp->left;
                flag=0;
            }else if(element>temp->element){
                parent = temp;
                flag=1;
                temp=temp->right;
            }
        }

        temp = (pTree)malloc(sizeof(tre));
        temp->element=element;
        temp->left=temp->right=NULL;
        if(flag){
            parent->right=temp;
        }else{
            parent->left=temp;
        }
    }

    return tree;
}

/*在二叉搜索樹中刪除一個元素
    算法思想：
        1.首先查找到該元素
        2.如果該元素是葉子節點，直接刪除
        3.如果該元素有一個孩子節點，直接把孩子節點掛載到該節點的父節點上
        4.如果該節點有兩個孩子，由兩種方法
            a.在該節點的左子樹中找到最大元素節點T，把該節點的值替換成T的值，然后執行對T的刪除操作
            b.在該節點的右子樹中找最小元素的節點T，把該節點的值替換為T的值，然后執行對T的刪除操作
        注：找最大或者最小元素是因為最大最小元素是葉子節點或者只有一個孩子。
*/
pTree deleteElement(pTree tree,elementType element){
    pTree temp;
    if(!tree){
        printf("the element don't search in this tree\n");
    }else if(element<tree->element){
        tree->left=deleteElement(tree->left,element);
    }else if(element>tree->element){
        tree->right = deleteElement(tree->right,element);
    }else{//找到需要刪除的元素節點
        if(tree->left && tree->right){//該有兩個孩子節點
            temp = getMinElement(tree->right);/*獲取右子樹的最小值節點*/
            tree->element=temp->element;
            tree->right=deleteElement(tree->right,temp->element);
        }else{
            temp=tree;
            if(!tree->left){
                tree=tree->right;
            }else if(!tree->right){
                tree=tree->left;
            }
            free(temp);
        }
    }
    return tree;
}

/*使用非遞歸的方法
pTree deleteElement2(pTree tree,elementType element){
    pTree temp,maxSubNode,flag,temp2;
    if(!tree){
        printf("the tree is empty,don't allow delete elememt\n");
    }else{
       temp = find(element,tree);
       if(temp==NULL){
            printf("the element don't exsit in this tree\n");
       }else{
            if(temp->left && temp->right){
                maxSubNode = getMinElement(temp->right);
                temp->element = maxSubNode->element;
            }else{
                maxSubNode = temp;
            }

                temp2=maxSubNode;
                if(!maxSubNode->left){
                    maxSubNode=maxSubNode->right;
                }else if(!maxSubNode->right){
                    maxSubNode=maxSubNode->left;
                }
                free(temp2);
       }

    }
    return tree;
}*/


//先序遍歷
void preOrderTraversal(pTree tree){
    if(tree){
        printf("%d ",tree->element);
        preOrderTraversal(tree->left);
        preOrderTraversal(tree->right);
    }
}

/*=====================================調整樹為平衡二叉樹===============================================*/

int getMaxValue(int a,int b){
    return a > b ? a : b ;
}

/*獲取二叉樹的樹高*/
int getHeight(pTree tree){
    int leftHeight,rightHeight;
    if(tree){
        leftHeight = getHeight(tree->left);
        rightHeight = getHeight(tree->right);
        return (leftHeight>rightHeight ? leftHeight : rightHeight)+1;
    }
    return 0;
}
/*
左單旋操作：將A與B進行LL旋轉，並更新A和B的新高度，返回新的根節點B
A必須有一個左子節點B
*/
pTree singleLeftRatation(pTree A){
    pTree B = A->left;
    A->left=B->right;
    B->right = A;
    A->treeHeight = getMaxValue(getHeight(A->left),getHeight(A->right))+1;
    B->treeHeight = getMaxValue(B->left,A->treeHeight)+1;
    return B;
}

/*右單旋:將A與B進行RR旋轉，並更新A與B的高度,返回新的根節點B
注：A必須有一個右節點B
*/
pTree singleRightRatation(pTree A){
    pTree B = A->right;
    A->right = B->left;
    B->left = A;
    A->treeHeight = getMaxValue(getHeight(A->left),getHeight(A->right))+1;
    B->treeHeight = getMaxValue(getHeight(B->right),A->treeHeight);
    return B;
}

/*
將A做LR旋轉，返回新的根節點C
A必須有一個左自己的B，B必須有一個右子節點C
*/
pTree doubleLeftRightRatation(pTree A){
    /*先對B，C進行RR旋轉,C被返回*/
    A->left = singleRightRatation(A->left);
    /*在對A和C進行LL旋轉，返回新的根節點C*/
    return singleLeftRatation(A);
}

/*
對A進行RL旋轉，返回新的根節點C
注：A必須有一個右子節點B，B必須有一個左子節點C
*/
pTree doubleRightLeftRatation(pTree A){
    /*先對B，C進行LL旋轉,返回新的根節點C*/
    A->right = singleLeftRatation(A->right);
    /*在對A，C進行RR旋轉，返回新的根節點C*/
    return singleRightRatation(A);
}

/*對二叉搜索樹進行插入，插入后調整樹的平衡*/
pTree AVLInsert(pTree tree,elementType element){
    if(!tree){
        tree = (pTree)malloc(sizeof(tre));
        tree->element = element;
        tree->left=tree->right = NULL;
        tree->treeHeight=0;
    }else if(element<tree->element){
        tree->left = AVLInsert(tree->left,element);
        //判斷平衡因子是否等於2
        if(getHeight(tree->left)-getHeight(tree->right) == 2){
            if(element<tree->left->element){//element往tree的左子樹的左子樹插入導致平衡因子大於2，進行LL調整的
                tree = singleLeftRatation(tree);
            }else{//element往tree的左子樹的右子樹插入導致平衡因子大於2，進行LR調整
                tree = doubleLeftRightRatation(tree);
            }
        }
    }else if(element>tree->element){
        tree->right = AVLInsert(tree->right,element);
        //判斷平衡因子是否等於2
        if(getHeight(tree->right)-getHeight(tree->left) == 2){
            if(element>tree->right->element){//element往tree的右子樹的右子樹插入導致平衡因子大於2，進行RR調整
                tree = singleRightRatation(tree);
            }else{//element往tree的右子樹的左子樹插入導致平衡因子大於2，進行RL調整
                tree = doubleRightLeftRatation(tree);
            }
        }
    }/* else 如果找到了，就不進行插入*/

    tree->treeHeight = getMaxValue(getHeight(tree->left),(getHeight(tree->right)))+1;
    return tree;
}


void main(){
    printf("\n==========普通插入=====================================\n");
    int findElement=33;
    int deleteData=41;
    pTree tree=insert(NULL,30);
    tree=insert(tree,15);
    tree=insert(tree,41);
    tree=insert(tree,33);
    tree=insert(tree,50);
    tree=insert(tree,35);
    preOrderTraversal(tree);
    printf("\n");
    printf("The find element is:%d,the result is %d \n",findElement,find(findElement,tree)->element);
    printf("The min element:%d\n",getMinElement(tree)->element);
    printf("The max element:%d\n",getMaxElement(tree)->element);
    //printf("delete the elemet %d\n",deleteData);
    //deleteElement(tree,deleteData);
    printf("\nordinary tree preOrder\n");
    preOrderTraversal(tree);

    printf("\n==========AVL插入=====================================\n");

    pTree AVLTree=AVLInsert(NULL,30);
    AVLTree=AVLInsert(AVLTree,15);
    AVLTree=AVLInsert(AVLTree,41);
    AVLTree=AVLInsert(AVLTree,33);
    AVLTree=AVLInsert(AVLTree,50);
    AVLTree=AVLInsert(AVLTree,35);
    printf("\n");
    printf("The find element is:%d,the result is %d \n",findElement,find(findElement,AVLTree)->element);
    printf("The min element:%d\n",getMinElement(AVLTree)->element);
    printf("The max element:%d\n",getMaxElement(AVLTree)->element);
    //printf("delete the elemet %d\n",deleteData);
    //deleteElement(AVLTree,deleteData);
     printf("\nAVL tree preOrder\n");
    preOrderTraversal(AVLTree);

}

 

依次插入 30 15 41 33 50 35

則

 

這個和程序運行的結果是一致的：