二分查找，二叉排序树与平衡二叉树

最新推荐文章于 2024-04-12 21:41:01 发布

Kentos(acoustic ver.)

最新推荐文章于 2024-04-12 21:41:01 发布

阅读量972

点赞数

文章标签：数据结构二分查找二叉树递归算法

本文链接：https://blog.csdn.net/weixin_56631477/article/details/121901880

版权

查找：给定一个值，在集合中确定一个关键字等于给定值的记录或数据元素

-静态查找与动态查找

-线性表查找，树表查找以及散列表查找

二分查找：只能用于顺序存储结构的有序线性表查找

- 时间复杂度O( $log_{2}n$ )：深度为n的二叉判定树有 $2^{n}-1$ 个结点

- 平均查找长度ASL = $\sum$ 第i层元素个数*第i层元素比较次数（层数）

数据结构定义

typedef struct LNode *PtrToLNode;
struct LNode {
    int Data[MaxSize]; //用一维数组存储数据
    int Last; //最后一个元素的下标
};
typedef PtrToLNode List;
List L;

二分查找算法

int BinarySearch(List Tbl, int K) //二分查找关键字为K的元素
{
    int left, right, mid;
    left = 1; //初始左边界
    right = Tbl->Last; //初始右边界
    while(left <= right) {
        mid = (left + right)/2; //计算中间元素下标
        if(Tbl->Data[mid] > K) //若K比中间值小
            right = mid - 1; //调整右边界
        else if(Tbl->Data[mid] < K) //若K比中间值大
            left = mid + 1; //调整左边界
        else
            return mid;
    }
    return NotFound; //#define NotFound -1 查找不成功
}

二分查找算法改进版

- 找相同元素的第一个

int BinarySearch(List Tbl, int K) //二分查找关键字为K的元素中的第一个
{
    int left, right, mid;
    left = 1; //初始左边界
    right = Tbl->Last; //初始右边界
    while(left < right) {
        mid = (left + right)/2; //计算中间元素下标
        if(Tbl->Data[mid] >= K) //若K比中间值小或等于中间值
            right = mid; //调整右边界
        else //若K比中间值大
            left = mid + 1; //调整左边界
    }
    if(Tbl->Data[right] == K)
        return right; //查找成功，返回下标
    return NotFound; //#define NotFound -1 查找不成功
}

同样的思想可以应用到树表的查找——二叉排序树

- 特点：左子树上所有结点的值都小于它的根结点的值，右子树上所有结点的值都大于它的根结点的值，它的左右子树分别也为二叉排序树。

- 时间复杂度：介于O( $log_{2}n$ )和O(n)之间

数据结构定义

typedef char ElementType;
typedef struct TNode *Position;
typedef Position BinTree; //二叉树类型
struct TNode{ //树结点定义
    ElementType Data;
    BinTree Left, Right;
};

二叉排序树的构造

- 从空的二叉排序树开始依次插入结点

BinTree Insert(BinTree BST, Position X) //二叉排序树的插入操作
{
    if(!BST) { //若原树为空，生成并返回一个结点二叉搜索树
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X->Data;
        BST->Left = BST->Right = NULL;
    }
    else { //开始查找插入元素的位置
        if(X->Data <= BST->Data) //这里在运行的时候有问题
            BST->Left = Insert(BST->Left, X); //递归插入左子树
        else if(X->Data > BST->Data)
            BST->Right = Insert(BST->Right, X); //递归插入右子树
    }
    return BST;
}

BinTree CreateBinTree(BinTree BST, int r[], int n) //建立二叉搜索树，传入待排序列及其大小
{
    Position s;
    s = (Position)malloc(sizeof(TNode));
    for(int i = 0; i < n; i++) {
        s->Data = r[i];
        s->Left = s->Right = NULL;
        Insert(BST, s);
    }
    return BST;
}

二叉排序树的查找操作

- 查找关键字，返回查找次数

- 查找最大值/最小值

- 递归算法

Position Find(BinTree BST, ElementType X) //查找关键字，返回查找次数
{
    int cnt = 0;
    if(!BST)
        return NULL;
    if(X > BST->Data) {
        cnt++;
        return Find(BST->Right, X); //在右子树递归查找
    }
    else if(X < BST->Data) {
        cnt++;
        return Find(BST->Left, X); //在左子树递归查找
    }
    else //X == BST->Data
        return cnt; //查找成功，返回当前结点
}

Position FindMin(BinTree BST) //查找最小值
{
    if(!BST)
        return NULL;
    else if(!BST->Left)
        return BST; //找到最左边的叶子结点并返回
    else
        return FindMin(BST->Left); //沿着左分支继续查找
}

Position FindMax(BinTree BST) //查找最大值
{
    if(!BST)
        return NULL;
    else if(!BST->Right)
        return BST; //找到最右边的叶子结点并返回
    else
        return FindMin(BST->Right); //沿着右分支继续查找
}

-迭代算法

Position Find(BinTree BST, ElementType X)
{
    while(BST) {
        if(X > BST->Data)
            BST = BST->Right; //向右子树中移动，继续查找
        else if(X < BST->Data)
            BST = BST->Left; //向左子树中移动，继续查找
        else //X == BST->Data
            break;
    }
    return BST;
}

Position FindMin(BinTree BST)
{
    if(BST)
        while(BST->Left)
            BST = BST->Left; //沿左子树一直向下，直到最左端点
    return BST;
}

Position FindMax(BinTree BST)
{
    if(BST)
        while(BST->Right)
            BST = BST->Right; //沿右子树一直向下，直到最右端点
    return BST;
}

二叉排序树的删除操作

- 左右孩子都存在

- 只存在左/右孩子，或叶子结点

BinTree Delete(ElementType X, BinTree BST) //二叉排序树的删除
{
    Position temp; //临时变量
    if(!BST)
        printf("要删除的元素未找到\n");
    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) { //被删除的结点有左右子树
            temp = FindMin(BST->Right); //在右子树中找到最小元素
            BST->Data = temp->Data; //填充被删除的结点
            //从右子树中删除最小元素，其右孩子换到它的位置上（因为是最小结点所以没有左孩子）
            BST->Right = Delete(BST->Data, BST->Right);
            /*还可以在左子树里找到最大的元素填充被删除结点，如：
             temp = FindMin(BST->Left);
             BST->Data = temp->Data;
             BST->Left = Delete(BST->Data, BST->Left);
             //因为是左子树里的最大结点所以没有右孩子
             */
        }
        else {
            temp = BST;
            if(!BST->Left) //被删除的结点只有右孩子（左子树为空）
                BST = BST->Right; //将原结点改为其右孩子
            else if(!BST->Right) //被删除的结点只有左孩子
                BST = BST->Left;
            //被删除的结点是叶子结点则直接删除
            free(temp);
        }
    }
    return BST;
}

对以上操作的简单测试

void InorderTraversal(BinTree BST) //中序遍历输出二叉排序树所存序列
{
    if(BST) {
        InorderTraversal(BST->Left); //先访问左子树
        printf("%-3d", BST->Data); //再访问根结点
        InorderTraversal(BST->Right); //最后访问右子树
    }
}

int main(void)
{
    BinTree T;
    int i, n, r[MaxSize], x, y, z; //n为待排序列大小
    printf("请输入待排序列元素个数：");
    scanf("%d", &n);
    printf("请输入待排序列：");
    for(i = 0; i < n; i++) {
        scanf("%d", &x);
        r[i] = x;
    }
    
    T = (BinTree)malloc(n*sizeof(struct TNode));
    CreateBinTree(T, r, n); //建立二叉排序树
    
    printf("树中最大的元素为：%-3d\n", FindMax(T)->Data);
    printf("树中最小的元素为：%-3d\n", FindMin(T)->Data);
    
    printf("请输入想要查找的元素：");
    scanf("%d", &y);
    printf("查找次数为：%-3d\n", Find(T, y));
    
    printf("请输入要删除的元素：");
    scanf("%d", &z);
    Delete(z, T);
    printf("删除之后的序列为：");
    InorderTraversal(T);
    printf("\n");
    
    return 0;
}

平衡二叉树

特点：根结点的左右子树的深度最多相差1，且根结点的左右子树也为平衡二叉树

平衡因子：左右子树深度之差

平衡二叉树的构造：插入一个结点时，首先检查插入是否破坏了树的平衡性，若是，则找出以距离插入结点最近且平衡因子大于1的结点为根的子树，调整这棵子树个结点之间的连接关系，使之成为新的平衡子树。

数据结构定义

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

插入算法

AVLTree Insert(AVLTree T, ElementType X)
{
    if(!T) { //若插入空树，则新建包含一个结点的树
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 1;
        T->Left = T->Right = NULL;
    }
    else if(X < T->Data) {
        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(X > T->Data) {
        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); //右-左双旋
        }
    }
    T->Height = Max(GetHeight(T->Left),GetHeight(T->Right)) + 1;
    return T;
}

要求：掌握四种不平衡情况以及它们对应的旋转调整方法

AVLTree SingleLeftRotation(AVLTree A) //LL型左单旋
{
    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;
}

AVLTree SingleRightRotation(AVLTree A) //RR型右单旋
{
    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->Right), A->Height) + 1;
}

AVLTree DoubleLeftRightRotation(AVLTree A) //LR型左-右双旋
{
    //B为A的左子树，C为B的右子树
    A->Left = SingleRightRotation(A->Left); //将B、C做右单旋，返回C
    return SingleLeftRotation(A); //将A、C做左单旋，返回C
}

AVLTree DoubleRightLeftRotation(AVLTree A) //RL型右-左双旋
{
    //B为A的右子树，C为B的左子树
    A->Right = SingleLeftRotation(A->Right); //将B、C做左单旋，返回C
    return SingleRightRotation(A); //将A、C做右单旋，返回C
}