数据结构---搜索二叉树的插入、删除、查找

搜索二叉树:

  • 二叉搜索树又称二叉排序树,它或者是一棵空树,或者是具有以下性质的二叉树

    1. 若它的左子树不为空,则左子树上所有节点的值都小于根节点的值

    2. 若它的右子树不为空,则右子树上所有节点的值都大于根节点的值

    3. 它的左右子树也分别为二叉搜索树

    4. 例如:int a [] = {5,3,4,1,7,8,2,6,0,9};
      《数据结构---搜索二叉树的插入、删除、查找》

非递归

搜索二叉树的插入:

int  BSTreeInsert(BSTreeNode** pptree,DataType x)
{
    BSTreeNode*parent;
    BSTreeNode*cur;
    assert(pptree);
    if(*pptree==NULL)//如果为空树,则直接创建一个节点插入数值
    {
     *pptree=BSTreeBuyNode(x);
     return 0;
    }
    parent=NULL;
    cur=*pptree;
    while(cur)
    {
        if(cur->_data>x)
        {
            parent=cur;
            cur=cur->_left;
        }
        else if(cur->_data<x)
        {
            parent=cur;
            cur=cur->_right;
        }
        else
        {
            return -1;
        }


    }//找到要插入的位置
    if(parent->_data<x)
    {
       parent->_right=BSTreeBuyNode(x);//要插入的数比节点值大,则插在右边
    }
    else
    {
        parent->_left=BSTreeBuyNode(x);
    }

    return 0;//插入成功
}

查找:

BSTreeNode*BSTreeFind(BSTreeNode* tree,DataType x)
 {
     assert(tree);
    while(tree)
    {
         if(tree->_data>x)
     {
         tree=tree->_left;
     }
     else if(tree->_data<x)
     {
         tree=tree->_right;
     }
     else
     {
         return tree;
     }
    }
    return -1;//查找失败

 }

删除:
1、要删除的节点左、右都为空;
2、要删除的节点左为空;
3、要删除的节点右为空;
4、两边都不为空。
第一种情况可以归为二三类一起处理。

int BSTreeRemove(BSTreeNode**pptree, DataType x)
  {

    BSTreeNode *cur = *pptree;//用cur记录当前根节点
    BSTreeNode *parent = *pptree;//父亲节点指向根节点
    BSTreeNode *del = NULL;//记录要删除的点

    while (cur)
    {
        if (cur->_data > x)//要删除的点比当前根节点值小,向左走,同时更新父亲节点
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_data < x)//同上
        {
            parent = cur;
            cur = cur->_right;
        }
        else//找到节点后进行删除工作
        {
            del = cur;

            if (cur->_left == NULL) //1、左孩子为空
            {
                if (parent->_left == cur)
                    parent->_left = cur->_right;
                else if (parent->_right == cur)
                    parent->_right = cur->_right;
                else if (parent == cur) //没有父亲节点时
                   *pptree = parent->_right;
            }
            else if (cur->_right == NULL) //2、右孩子为空
            {
                if (parent->_left == cur)
                    parent->_left = cur->_left;
                else if (parent->_right == cur)
                    parent->_right = cur->_left;
                else if (parent == cur) //没有父亲节点时
                    *pptree = parent->_left;
            }
            else//3、左右孩子都不为空
            {
                BSTreeNode *sub = cur->_right;
                while (sub->_left)
                {
                    parent = sub;
                    sub = sub->_left;
                }

                del = sub;
                cur->_data = sub->_data;//交换最做节点和根节点的值

                if (parent->_left == sub)
                    parent->_left = sub->_right;
                else 
                    parent->_right = sub->_right;
            }

            free(del);//删除此节点
            del = NULL;
            return 0;//删除成功

        }
    }

    return -1;//删除失败

  }

递归

插入:

int BSTreeInsertR(BSTreeNode**pptree,DataType x)//插入
  {
      assert(pptree);
      if(NULL==*pptree)//空
      {
          *pptree=BSTreeBuyNode(x);
      }
      if((*pptree)->_data>x)
      return  BSTreeInsertR(&(*pptree)->_left,x);//(*pptree)代表根节点指针
          else if((*pptree)->_data<x)
       return BSTreeInsertR(&(*pptree)->_right,x);
      else
          return -1;

  }

删除:

int BSTreeRemoveR(BSTreeNode** pptree, DataType x) //删除
  {
      BSTreeNode*cur=*pptree;
      BSTreeNode*del=cur;
      BSTreeNode*sub=NULL;
      if(NULL==*pptree)//空
      {
          return -1;
      }
      assert(pptree);
          if(cur->_data>x)
          {
              return BSTreeRemoveR(&(cur->_left),x);
          }
          else if(cur->_data<x)
          {
              return BSTreeRemoveR(&(cur->_right),x);
          }
          else//找到后进行删除
          {
              del=cur;//记录要删除的点
              if(cur->_left==NULL)//左为空
              {
                  *pptree=cur->_right;
              }
              else if(cur->_right==NULL)//右为空
              {
                  *pptree=cur->_left;
              }
              else//左右都不为空
              {
                 sub=cur->_right;
                 while(sub->_left) {
                     sub=sub->_left;
                 }
                 del=sub;
                 cur->_data=sub->_data;  
                 return BSTreeRemoveR(&(cur->_right),sub->_data);
              }
              free(del);
              del=NULL;
              return 0;

          }
     }

查找:

 BSTreeNode* BSTreeFindR(BSTreeNode* tree,DataType x)//查找
  {
      if(NULL==tree)
          return -1;
      assert(tree);
      while(tree)
      {
       if(tree->_data>x)
          return BSTreeFindR(tree->_left,x);
        else if(tree->_data<x)
          return BSTreeFindR(tree->_right,x);
        else
          return tree;
      }
      return -1;
  }  
    原文作者:二叉查找树
    原文地址: https://blog.csdn.net/adzn1/article/details/79390086
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞