数据结构学习笔记（五）：树（中）：二叉搜索树，平衡二叉树

本文链接：https://blog.csdn.net/jurbo/article/details/74859563

请跟着上一讲数据结构学习笔记（四）：树（上）：树的表示，二分查找，二叉树，先中后层次遍历继续学习

4.1 二叉搜索树

4.1.1 二叉搜索树及查找

什么是二叉搜索树

回顾上一讲提到的查找问题：

静态查找（集合元素不动，只发生查找操作）和动态查找（集合元素经常动态变化，经常发生插入删除）
针对动态查找，数据如何组织？

静态查找很好的解决方法是二分查找，因为提前有效的组织了数据，使它有序化，使线性的查找过程变成了在类似树中的查找过程，查找效率就是树的高度。

因此，我们想，有没有一种办法。直接把数按照一定的规则放到树里面，不要放在数组里面。放在树里的好处是，动态性比较强，比在线性结构里面方便。这就是我们说的二叉搜索树（二叉查找树）。

二叉搜索树，也称为二叉排序树或二叉查找树。

二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质：

非空左子树的所有键值小于其根结点的键值
非空右子树的所有键值大于其根结点的键值
左、右子树都是二叉搜索树

例子：

这里写图片描述

二叉搜索树操作的查找函数

这里写图片描述

二叉搜索树的查找操作：Find

查找从根结点开始，如果树为空，返回 NULL。

若搜索树非空，则根结点关键字和 X进行比较，并进行不同处理：

若X 小于根结点键值，只需在左子树中继续搜索
若X 大于根结点的键值，在右子树中进行搜索
如果两个比较结果是相等，搜索完成，返回指向该结点的指针。

这里写图片描述

Position Find(ElementType X,BinTree BST)
{
    if(!BST)
        return NULL; //查找失败
    if(X>BST->Data)
        return Find(X,BST->Right); //在右子树中继续查找
    else if(X<BST->Data)
        return Find(X,BST->Left);
    else //X==BST->Data
        return BST;  //查找成功，返回结点的找到结点的地址
}

由于非递归函数的执行效率高，可将“尾递归”函数改为迭代函数。

Position IterFind(ElementType X,BinTree BST)
{
    while(BST)
    {
        if(X>BST->Data)
            BST=BST->Right; //向右子树中移动，继续查找
        else if(X<BST->Data)
            BST=BST->Left;  //向左子树中移动，继续查找
        else
            return BST;     //查找成功，返回结点的找到结点的地址
    }
    return NULL; //查找失败
}

查找的效率决定于树的高度。

查找最大和最小元素

最大元素一定是在树的最右分支的端结点上。
最小元素一定是在树的最左分支的端结点上。

这里写图片描述

Positon FindMin(BinTree BST)
{
    if(!BST)
        return NULL;  //空的二叉搜索树，返回NULL
    else if(!BST->Left)
        return BST;   //找到最左叶结点并返回
    else 
        return FindMin(BST->Left); //沿左分支继续查找
}

Position FindMax(BinTree BST)
{
    if(BST)
        while(BST->Right) //沿右分支继续查找，直到最右叶结点
            BST=BST->Right;
    return BST;
}

4.1.2 二叉搜索树的插入

关键是要找到元素应该插入的位置，可以采用与 Find 类似的方法。

这里写图片描述

BinTree Insert(ElementType X,BinTree BST)
{
    //若原树为空，生成并返回一个结点的二叉搜索树
    if(!BST)
    {
        BST= malloc(sizeof(struct TreeNode));
        BST->Data=X;
        BST->Left=BST->Right=NULL;
    }
    //开始找要插入元素的位置
    else
    {
        if(X<BST->Data)
            BST->Left=Insert(X,BST->Left); //递归插入左子树
        else if(X>BST->Data)
            BST->Right=Insert(X,BST->Right);//递归插入右子树
    }
    return BST;
}

例子：

这里写图片描述

4.1.3 二叉搜索树的删除

考虑三种情况：

要删除的是叶结点：直接删除，并再将其父结点指针置为NULL
要删除的结点只有一个孩子结点：将其父结点的指针指向要删除结点的孩子结点
要删除的结点有左、右两棵子树：用另一结点替代被删除结点：右子树的最小元素或者左子树的最大元素

BinTree Delete(ElementType X,BinTree BST)
{
    Position Tmp;
    if(!BST)
        printf("要删除的元素未找到");
    else if(X<BST->Data)
        BST->Left=Delete(X,BST->Left); //左子树递归删除
    else if(X>BST->Data)
        BST->Right=Delete(X,BST->Right); //右子树递归删除
    else  //找到要删除的结点
    {
        if(BST->Left && BST->Right) //被删除的结点有左右两个子结点
        {
            Tmp=FindMin(BST->Right); //在右子树中招最小的元素填充删除结点
            BST->Data=Tmp->Data;
            BST->Right=Delete(BST->Data,BST->Right); //在删除结点的右子树中删除最小元素
        }
        else //被删除结点有一个或无子节点
        {
            Tmp=BST;
            if(!BST->Left) //有右孩子或无子结点
                BST=BST->Right;
            else if(!BST->Right)//有左孩子或无子结点
                BST=BST->Left;
            free(Tmp);
        }
    }
    return BST;
}

C 语言代码二叉搜索树的插入与删除

BinTree Insert( BinTree BST, ElementType X )
{
    if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }
    else { /* 开始找要插入元素的位置 */
        if( X < BST->Data )
            BST->Left = Insert( BST->Left, X );   /*递归插入左子树*/
        else  if( X > BST->Data )
            BST->Right = Insert( BST->Right, X ); /*递归插入右子树*/
        /* else X已经存在，什么都不做 */
    }
    return BST;
}

BinTree Delete( BinTree BST, ElementType X ) 
{ 
    Position Tmp; 

    if( !BST ) 
        printf("要删除的元素未找到"); 
    else {
        if( X < BST->Data ) 
            BST->Left = Delete( BST->Left, X );   /* 从左子树递归删除 */
        else if( X > BST->Data ) 
            BST->Right = Delete( BST->Right, X ); /* 从右子树递归删除 */
        else { /* BST就是要删除的结点 */
            /* 如果被删除结点有左右两个子结点 */ 
            if( BST->Left && BST->Right ) {
                /* 从右子树中找最小的元素填充删除结点 */
                Tmp = FindMin( BST->Right );
                BST->Data = Tmp->Data;
                /* 从右子树中删除最小元素 */
                BST->Right = Delete( BST->Right, BST->Data );
            }
            else { /* 被删除结点有一个或无子结点 */
                Tmp = BST; 
                if( !BST->Left )       /* 只有右孩子或无子结点 */
                    BST = BST->Right; 
                else                   /* 只有左孩子 */
                    BST = BST->Left;
                free( Tmp );
            }
        }
    }
    return BST;
}

4.2 平衡二叉树（AVL 树）

不同的结点插入顺序，形成的二叉搜索树也不同，查找效率（平均查找长度ASL）也不同。

例：

这里写图片描述

这引出了一个问题，我的树结构应该如何设计，查找效率才最高？（树越矮，查找效率越高。因此最好平衡，引出平衡二叉树）

4.2.1 什么是平衡二叉树

平衡二叉树（可以说是搜索二叉树的更高要求版）

平衡因子（简称BF）：BF（T）=左子树的高度-右子树的高度

平衡二叉树（AVL 树）：空树，或者任一结点左、右子树高度差的绝对值不超过1。

例子：

这里写图片描述

平衡是想要树的高度低一点，因为越平衡越低，越不平衡往一边倒，树的高度越高。

平衡二叉树的最小结点数： n(h)=n(h-1)+n(h-2)+1

4.2.2 平衡二叉树的调整

平衡二叉树是特殊的搜索二叉树，因此搜索二叉树能执行的查找，插入，删除操作，它也能做。

但是需要考虑，插入的时候会把原来平衡的平衡二叉树，会不平衡了。

RR旋转

这里写图片描述

LL旋转

这里写图片描述

LR旋转

这里写图片描述

RL旋转

这里写图片描述

C 语言代码 AVL树的旋转与插入

typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode{
    ElementType Data; /* 结点数据 */
    AVLTree Left;     /* 指向左子树 */
    AVLTree Right;    /* 指向右子树 */
    int Height;       /* 树高 */
};

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

AVLTree SingleLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B */
  /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */     

    AVLTree B = A->Left;
    A->Left = B->Right;
    B->Right = A;
    A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
    B->Height = Max( GetHeight(B->Left), A->Height ) + 1;

    return B;
}

AVLTree DoubleLeftRightRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */

    /* 将B与C做右单旋，C被返回 */
    A->Left = SingleRightRotation(A->Left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}

/*************************************/
/* 对称的右单旋与右-左双旋请自己实现 */
/*************************************/

AVLTree Insert( AVLTree T, ElementType X )
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    } /* if (插入空树) 结束 */

    else if ( X < T->Data ) {
        /* 插入T的左子树 */
        T->Left = Insert( T->Left, X);
        /* 如果需要左旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
            if ( X < T->Left->Data ) 
               T = SingleLeftRotation(T);      /* 左单旋 */
            else 
               T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */

    else if ( X > T->Data ) {
        /* 插入T的右子树 */
        T->Right = Insert( T->Right, X );
        /* 如果需要右旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
            if ( X > T->Right->Data ) 
               T = SingleRightRotation(T);     /* 右单旋 */
            else 
               T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */

    /* else X == T->Data，无须插入 */

    /* 别忘了更新树高 */
    T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;

    return T;
}