【数据结构初学笔记12】第四章二叉搜索树与平衡二叉树

1.二叉搜索树BST

        包括：元素的查找（递归和迭代），最值元素的查找（递归和迭代），插入元素和删除元素。

#include <stdio.h>
#include <stdlib.h>
#define ElementType int
typedef struct TreeNode *BinTree;
struct TreeNode
{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};
// 01二叉搜索树的查找操作Find(递归实现)
BinTree 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
        return BST; //查找成功，返回结点的找到结点的地址
}
// 02二叉搜索树的查找操作Find(迭代实现)
BinTree 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; //查找失败
}
// 03二叉搜索树递归查找最小元素
BinTree FindMin(BinTree BST)
{
    if (!BST)
        return NULL; //空树，返回NULL
    else if (!BST->Left)
        return BST;
    else
        return FindMin(BST->Left);
}
// 04二叉搜索树迭代查找最小元素
BinTree IterFindMin(BinTree BST)
{
    if (BST)
        while (BST->Left)
            BST = BST->Left;
    return BST;
}
// 05插入元素
BinTree Insert(ElementType X, BinTree Pstr)
{
    if (!Pstr) //如果结点为空，则申请空间存放要插入的元素X
    {
        Pstr = (BinTree)malloc(sizeof(struct TreeNode));
        Pstr->Data = X;
        Pstr->Left = NULL;
        Pstr->Right = NULL;
    }
    //开始插入元素，X插入左子树，X插入右子树，X已经存在
    else if (X < Pstr->Data)
        Pstr->Left = Insert(X, Pstr->Left);
    else if (X > Pstr->Right)
        Pstr->Right = Insert(X, Pstr->Right);
    return Pstr;
}
// 06二叉搜索树删除元素：情况1删除叶结点，直接删除，修改父结点指针；情况2删除只有一个孩子的结点，将其父结点指向该结点的孩子结点；
//情况3删除有两个孩子的结点，搜索其左子树的最大元素或右子树的最小元素，替代要删除的结点元素，并在左子树中删除该元素。
BinTree Delete(ElementType X, BinTree BST)
{
    BinTree temp;
    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) //情况3左右子树都存在
    {
        temp = FindMin(BST->Right); //找到右子树中的最小元素
        BST->Data = temp->Data;
        BST->Right = Delete(temp->Data, BST->Right); //在右子树中删除该结点元素
    }
    else
    {
        temp = BST;
        if (!BST->Left) //情况2没有左子树（只有右子树或没有子树）
        {
            // BST->Data = BST->Right->Data;
            // BST->Left = BST->Right->Left;
            // BST->Right = BST->Right->Right;
            //不能这样用，BST指针存储当前要删除的结点的地址，而父结点保存的是当前结点的指针地址变量，即BST；
            // 故可以直接更改BST指针所保存的内容，来实现更改删除该结点。
            BST = BST->Right;
        }
        else if (!BST->Right) //情况2只有左子树
        {
            BST = BST->Left;
        }
        free(temp);
    }
    return BST;
}

2.平衡二叉树AVL

包括平衡二叉树的建立，左单旋，右单旋，左-右双旋和右-左双旋的实现，以及向平衡二叉树插入一个结点的方法。

#include <stdio.h>
#include <stdlib.h>
#define ElementType int
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 SingleRightRotation(AVLTree A)
{   /* 注意：A必须有一个右子结点B */
    /* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */

    AVLTree B = A->Right;
    A->Right = B->Left;
    B->Left = 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 DoubleRightLeftRotation(AVLTree A)
{   /* 注意：A必须有一个右子结点B，且B必须有一个左子结点C */
    /* 将A、B与C做两次单旋，返回新的根结点C */

    /* 将B与C做左单旋，C被返回 */
    A->Right = SingleLeftRotation(A->Right);
    /* 将A与C做左单旋，C被返回 */
    return SingleRightRotation(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;
}

结束

课程来源：浙江大学数据结构慕课MOOC