数据结构 学习笔记(五):树(中):二叉搜索树,平衡二叉树

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


4.1 二叉搜索树

4.1.1 二叉搜索树及查找

什么是二叉搜索树

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

  • 静态查找(集合元素不动,只发生查找操作)和动态查找(集合元素经常动态变化,经常发生插入删除)
  • 针对动态查找,数据如何组织?

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

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

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

二叉搜索树:一棵二叉树,可以为空;如果不为空,满足以下性质:

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

例子:

这里写图片描述

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

这里写图片描述

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

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

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

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

这里写图片描述

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;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值