平衡二叉树

亦凉 2022-08-27 11:56 9阅读 0赞

# 平衡二叉树 #

## 一、简介 ##

### 1.1定义 ###

平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法 平衡二叉树的常用算法有红黑树、AVL、Treap、伸展树等。 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于一个递归的数列，可以参考Fibonacci数列，1是根节点，F(n-1)是左子树的节点数量，F(n-2)是右子树的节点数量。

假设我们已经有棵平衡二叉树，现在让我们来看看插入节点后，原来节点失去平衡后，我们进行选择的处理方式。

![Center][]

平衡二叉树多用于查找数据，所以平衡二叉树又是颗二叉排序树。

### 1.2创建平衡二叉树 ###

创建平衡二叉树，我们采用依次插入节点的方式进行。而平衡二叉树上插入节点采用递归的方式进行。递归算法如下：

（1）若该树为一空树，那么插入一个数据元素为e的新节点作为平衡二叉树的根节点，树的高度增加1。

（2）若待插入的数据元素e和平衡二叉树（BBST）的根节点的关键字相等，那么就不需要进行插入操作。

（3）若待插入的元素e比平衡二叉树（BBST）的根节点的关键字小，而且在BBST的左子树中也不存在和e有相同关键字的节点，则将e插入在BBST的左子树上，并且当插入之后的左子树深度增加1时，分别就下列情况处理之。

(a)BBST的根节点的平衡因子为\-1（右子树的深度大于左子树的深度）：则将根节点的平衡因子更改为0，BBST的深度不变；

(b)BBST的根节点的平衡因子为0（左右子树的深度相等）：则将根节点的平衡因子修改为1，BBST的深度增加1；

若BBST的左子树根节点的平衡因子为\-1，则需进行先向左，后向右的双向旋转平衡处理，并且在旋转处理之后，修改根节点和其左，右子树根节点的平衡因子，树的深度不变；

（4）若e的关键字大于BBST的根节点的关键字，而且在BBST的右子树中不存在和e有相同关键字的节点，则将e插入到BBST的右子树上，并且当插入之后的右子树深度加1时，分别就不同的情况处理之。

（a）BBST的根节点的平衡因子是1（左子树的深度大于右子树的深度）：则将根节点的平衡因子修改为0，BBST的深度不变；

（b）BBST的根节点的平衡因子是0（左右子树的深度相等）：则将根节点的平衡因子修改为\-1，树的深度加1；

（c）BBST的根节点的平衡因子为\-1（右子树的深度大于左子树的深度）：若BBST的右子树根节点的平衡因子为1，则需要进行两次选择，第一次先向右旋转，再向左旋转处理，并且在旋转处理之后，修改根节点和其左，右子树根节点的平衡因子，树的深度不变；

若BBST的右子树根节点的平衡因子为1，则需要进行一次向左的旋转处理，并且在左旋之后，更新根节点和其左，右子树根节点的平衡因子，树的深度不变；

### 1.3作用 ###

对于一般的二叉搜索树（Binary Search Tree），其期望高度（即为一棵平衡树时）为log2n，其各操作的时间复杂度（O(log2n)）同时也由此而决定。但是，在某些极端的情况下（如在插入的序列是有序的时），二叉搜索树将退化成近似链或链，此时，其操作的时间复杂度将退化成线性的，即O(n)。我们可以通过随机化建立二叉搜索树来尽量的避免这种情况，但是在进行了多次的操作之后，由于在删除时，我们总是选择将待删除节点的后继代替它本身，这样就会造成总是右边的节点数目减少，以至于树向左偏沉。这同时也会造成树的平衡性受到破坏，提高它的操作的时间复杂度。

平衡二叉搜索树（Balanced Binary Tree）具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。常用算法有红黑树、AVL、Treap、伸展树等。在平衡二叉搜索树中，我们可以看到，其高度一般都良好地维持在O（log2n），大大降低了操作的时间复杂度。

## 二、程序实现 ##

#include <stdio.h>
    #include <stdlib.h>
    /************************************************************************/
    /*                    平衡二叉树---AVL                                  */
    /************************************************************************/
    #define LH +1
    #define EH  0
    #define RH -1
    typedef int ElemType;
    typedef struct BSTNode{
    ElemType data;
    int bf;//balance flag
    struct BSTNode *lchild,*rchild;
    }*PBSTree;
     
    void R_Rotate(PBSTree* p)
    {
    PBSTree lc = (*p)->lchild;
    (*p)->lchild = lc->rchild;
    lc->rchild = *p;
    *p = lc;
    }
     
    void L_Rotate(PBSTree* p)
    {
    PBSTree rc = (*p)->rchild;
    (*p)->rchild = rc->lchild;
    rc->lchild = *p;
    *p = rc;
    }
     
    void LeftBalance(PBSTree* T)
    {
    PBSTree lc,rd;
    lc = (*T)->lchild;
    switch (lc->bf)
    {
    case LH:
    (*T)->bf = lc->bf = EH;
    R_Rotate(T);
    break;
    case RH:
    rd = lc->rchild;
    switch(rd->bf)
    {
    case LH:
    (*T)->bf = RH;
    lc->bf = EH;
    break;
    case EH:
    (*T)->bf = lc->bf = EH;
    break;
    case RH:
    (*T)->bf = EH;
    lc->bf = LH;
    break;
    }
    rd->bf = EH;
    L_Rotate(&(*T)->lchild);
    R_Rotate(T);
    break;
    }
    }
     
    void RightBalance(PBSTree* T)
    {
    PBSTree lc,rd;
    lc= (*T)->rchild;
    switch (lc->bf)
    {
    case RH:
    (*T)->bf = lc->bf = EH;
    L_Rotate(T);
    break;
    case LH:
    rd = lc->lchild;
    switch(rd->bf)
    {
    case LH:
    (*T)->bf = EH;
    lc->bf = RH;
    break;
    case EH:
    (*T)->bf = lc->bf = EH;
    break;
    case RH:
    (*T)->bf = EH;
    lc->bf = LH;
    break;
    }
    rd->bf = EH;
    R_Rotate(&(*T)->rchild);
    L_Rotate(T);
    break;
    }
    }
     
    int InsertAVL(PBSTree* T,ElemType e,bool* taller)
    {
    if ((*T)==NULL)
    {
    (*T)=(PBSTree)malloc(sizeof(BSTNode));
    (*T)->bf = EH;
    (*T)->data = e;
    (*T)->lchild = NULL;
    (*T)->rchild = NULL;
    }
    else if (e == (*T)->data)
    {
    *taller = false;
    return 0;
    }
    else if (e < (*T)->data)
    {
    if(!InsertAVL(&(*T)->lchild,e,taller))
    return 0;
    if(*taller)
    {
    switch ((*T)->bf)
    {
    case LH:
    LeftBalance(T);
    *taller = false;
    break;
    case  EH:
    (*T)->bf = LH;
    *taller = true;
    break;
    case RH:
    (*T)->bf = EH;
    *taller = false;
    break;
    }
    }
    }
    else
    {
    if(!InsertAVL(&(*T)->rchild,e,taller))
    return 0;
    if (*taller)
    {
    switch ((*T)->bf)
    {
    case LH:
    (*T)->bf = EH;
    *taller = false;
    break;
    case EH:
    (*T)->bf = RH;
    *taller = true;
    break;
    case  RH:
    RightBalance(T);
    *taller = false;
    break;
    }
    }
    }
    return 1;
    }
     
    bool FindNode(PBSTree root,ElemType e,PBSTree* pos)
    {
    PBSTree pt = root;
    (*pos) = NULL;
    while(pt)
    {
    if (pt->data == e)
    {
    //找到节点，pos指向该节点并返回true
    (*pos) = pt;
    return true;
    }
    else if (pt->data>e)
    {
    pt = pt->lchild;
    }
    else
    pt = pt->rchild;
    }
    return false;
    }
    void InorderTra(PBSTree root)
    {
    if(root->lchild)
    InorderTra(root->lchild);
    printf("%d ",root->data);
    if(root->rchild)
    InorderTra(root->rchild);
    }
     
    int main()
    {
    int i,nArr[] = {1,23,45,34,98,9,4,35,23};
    PBSTree root=NULL,pos;
    bool taller;
    for (i=0;i<9;i++)
    {
    InsertAVL(&root,nArr[i],&taller);
    }
    InorderTra(root);
    if(FindNode(root,103,&pos))
    printf("\n%d\n",pos->data);
    else
    printf("\nNot find this Node\n");
    return 0;
    }

[Center]: /images/20220824/c2a7b874939446d0ad5d22b4310328f5.png