数据结构与算法分析--二叉排序树(二叉查找树,二叉搜索树)的查找、插入和删除操作

  • 什么是二叉排序树
    它表示一棵二叉树,并且包含以下性质:
    1)可能是一棵空树
    2)若不为空,那么其左子树结点的值都是小于根结点的值,右子树结点的值都是大于根结点的值
    3)左右子树都是二叉树。

  • 对于二叉排序树功能的介绍
    本文主要介绍的是二叉排序树的几种基本操作,包括查找、插入和删除操作。用到的二叉排序树如下图所示:
    《数据结构与算法分析--二叉排序树(二叉查找树,二叉搜索树)的查找、插入和删除操作》

  • 二叉排序树的建立
  • 二叉树结点的创建:
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild,*rchild,*parent;
}BiTNode,*BiTree;
  • 二叉排序树的创建过程
    二叉排序树的创建过程。主要包含两个部分:二叉排序树的创建和插入每个结点的过程。主要就是利用递归操作插入结点。具体过程如下:
    • 申请一个结点p的空间,存储数据和左右子树的指针。
  • 几种情况的判断:
  • 1.判断是否为空树,空树时,插入的节点直接为根结点
  • 2.插入结点的值>根结点的值,插入结点直接设置为右孩子。设置方式:根结点的右孩子子针直接连接插入结点。
  • 3.插入结点的值<根结点的值,插入结点直接设置为左孩子。设置方式 : 根结点的左孩子子针直接连接插入结点。
  • 4.进行递归操作。继续插入下个结点,此时的根结点就是刚刚插入的结点。
//创建一棵二叉排序树
void create(BiTree* root,int* keyArray,int length )
{
    int i;
    for(i=0;i<length;i++)
        insert(root,keyArray[i]);
}
//插入每个结点
void insert(BiTree* root,int data)
{
    //初始化插入的节点
    BiTree p=(BiTree)malloc(sizeof(BiTNode));
    p->data=data;
    p->lchild=p->rchild=NULL;
    //空树时,直接最为根结点
    if((*root)=NULL)
    {
        *root=p;
        return;
    }
    //插入到当前结点的左孩子
    if((*root)->lchild==NULL&&(*root)->data>data)
    {
        p->parent=(*root);
        (*root)->lchild=p;
        return;
    }
    if((*root)->rchild==NULL&&(*root)->data<data)
    {
        p->parent=(*root);
        (*root)->rchild=p;
        return;
    }
    if((*root)->data>data)
        insert(&(*root)->lchild,data);
    else if((*root)->data<data)
        insert(&(*root)->rchild,data);
    else
        return;
}

-二叉排序树的搜索和插入操作
二叉排序树的搜索过程:

  • 二叉树是否存在
  • 搜索结点的值是否等于T的值
  • 如果搜索结点的值小于T的值,那就进行递归操作继续搜索T的左子树。
  • 如果搜索结点的值大于T的值,那就进行递归操作继续搜索T的右子树。

二叉排序树的插入操作主要包括以下几个过程:

  • 1.首先判断插入结点,和树中结点是否存在重复,这时候用到的是结点的搜索操作,若没有重复的节点,就进行后面的插入操作。
  • 2.创建一个新结点,存储插入结点的值。
  • 3.如果是空树,插入结点直接插入进去。
  • 4.如果树不为空,插入结点的值小于最后一个结点的值,插入结点连接最后一个结点的左子树;插入结点的值大于最后一个结点的值,插入结点连接最后一个结点的右子树。
 /* 当二叉排序树T中不存在关键字key的数据元素时,插入key并返回true,否则返回false. */
BiTree SearchBST(BiTree T,int key,BiTree f,BiTree * p)
{
    if(!T)
    {
        *p=f;
        return NULL;
    }
    else if(key==T->data)
    {
        *p=T;
        return *p;
    }
    else if(key<T->data)
    {
        return SearchBST(T->lchild,key,T,p);
    }
    else
        return SearchBST(T->rchild,key,T,p);
}
BiTree InsertBTS(BiTree *T ,int key)
{
    BiTree p,s;
    //判断经过二叉树的查找,是否找得到所需结点
    if(!SearchBST(*T,key,NULL,&p))
    {
        //找不到结点,那首先生成一个结点(不存在重复结点)
        s=(BiTree)malloc(sizeof(BiTNode));
        s->data=key;
        s->lchild=NULL;
        s->rchild=NULL;

        if(!p)//最后一个结点是否在树里面,进入循环表示树不为空,进入查找。
        {
            *T=s;
        }
        if(key<p->data)
        {
            s=p->lchild;
        }
        else
        {
            s=p->rchild;
        }
        return s;
    }
    else
    {
        return NULL;
    }

}

.

查找删除结点操作

  • 判断键值是否等于当前结点的值,等于直接调用删除函数。
  • 如果键值小于当前结点的值,则递归调用查找删除结点,若值小于此结点的值,递归传入左子树,若大于递归传入右子树。

删除操作主要包含三种情况:
定义删除结点为p结点,q指针用于传递。

  • 删除结点的右子树为空的情况下
    把p结点的地址传给q指针,再把p的左子树的值传递给p,最后释放q。
  • 删除结点的左子树为空的情况下
    把p结点的地址传给q指针,再把p的右子树的值传递给p,最后释放q。
  • 删除结点的左右子树都不为空
    这种情况的主要思想是用删除结点的直接前驱去替换这个结点的值,最后只需要释放直接前驱的结点即可,框架结构是不需要调整的。(下面的删除方式是以找到左子树的直接前驱结点为例
    1.q指针指向删除结点的位置,s指针指向删除结点的左子树。
    2.然后循环搜索直接前驱结点,并用s指针指向这个前驱结点,q指向前驱结点的双亲节点。
    3.进行判断,如果删除的结点就是前驱结点的双亲节点,那么直接就把双亲节点替换到前驱结点的位置。如把99替换到100的位置。如果存在前驱结点的子树,那么就把删除结点的左子树连接前驱结点的左子树。例如103放到100的位置上。
    4。最后释放前驱结点。
BiTree Delete(BiTree *p)
{
    BiTree q,s;
    //右子树为空的情况下
    if((*p)->rchild==NULL) { q=*p; *p=(*p)->lchild;
        free(q);
    }
    else if((*p)->lchild==NULL) { q=*p; *p=(*p)->rchild;
        free(q);
    }
    //以直接前驱做替换
    else
    {
        q=*p;
        s=(*p)->lchild;
        while(s->rchild)
        {
            q=s;
            s=s->rchild;
        }
        (*p)->data=s->data;
        if(q!=*p)
        {
            q->rchild=s->lchild;
        }
        else
        {
            q->lchild=s->lchild;
        }
        free(s);
    }
    return s;
}

//删除二叉树模块
BiTree DeleteBST(BiTree *T ,int key)
{
    if(!*T)
    {
        return NULL;
    }
    else
    {
        if(key==(*T)->data) return Delete(T); else if(key<(*T)->data) { return DeleteBST(&((*T)->lchild),key); } else { return DeleteBST(&(*T)->rchild,key); } } }
    原文作者:查找算法
    原文地址: https://blog.csdn.net/CSDN_564174144/article/details/75286489
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞