数据结构-二叉搜索树

最新推荐文章于 2023-07-31 18:10:04 发布
最新推荐文章于 2023-07-31 18:10:04 发布
阅读量220 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zgege/article/details/80703293
版权

二叉搜索树的定义

二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树：

  1. 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

  2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

  3. 任意节点的左、右子树也分别为二叉查找树。

  4. 没有键值相等的节点。

这里写图片描述
二叉树搜索树的基本操作

  1. 二叉树搜索树插入（递归与迭代）

  2. 二叉树搜索树查找（递归与迭代）

  3. 二叉树搜索树删除（递归与迭代）

  4. 二叉树搜索树销毁

搜索二叉树的定义及初始化


typedef struct SearchTreeNode
{
      SearchTreeNode* rchild;
      SearchTreeNode* lchile;
      SearchTreeType data;
}SearchTreeNode;

//因为会修改根节点的指向，所以使用二级指针
void SearchTreeInit(SearchTreeNode** root)   
{
      if(root==NULL)
      {
            return ;
      }
      *root=NULL;
      return ;
}

二叉树搜索树创建新节点与

SearchTreeNode* SearchTreeCreateNode(SearchTreeType value)
{
      SearchTreeNode* newnode=(SearchTreeNode*)malloc(sizeof(SearchTreeNode));
      newnode->data=value;
      newnode->lchild=NULL;
      newnode->rchild=NULL;
      return newnode;
}

搜索二叉树销毁节点

void DelNodeSearchTree(SearchTreeNode* value)
{
      free(value);
      return ;
}

二叉搜索数插入新节点

这里写图片描述

//递归版本
void SearchTreeInsert(SearchTreeNode** root, SearchTreeType value)
{
      if(root==NULL)
      {
            return ;
      }
      if(*root==NULL)
      {
            //空树，直接插入
            SearchTreeNode* newnode=SearchTreeCreateNode(value);
            *root=newnode;
            return ;
      }
      //对于非空，采用递归插入
      SearchTreeNode* cur=*root;
      if(value<cur->data)
      {
            //递归插入左子树
            SearchTreeInsert(&cur->lchild,value);
      }
      if(value>cur->data)
      {
            //递归插入右子树
            SearchTreeInsert(&cur->rchild,value);
      }
      else
      {
            //关于等于的处理有很多，以下可以采用一种约定
            //我们约定这个二查搜索树不能重复
            //一旦重复，直接返回，插入失败
            return;
      }
      return ;



}

//非递归版本

void SearchTreeInsert(SearchTreeNode** root,SearchTreeType value)
{
      if(root==NULL)
      {
            return ;
      }
      //空树
      if(*root==NULL)
      {
            *root=SearchTreeCreateNode(value);
            return ;
      }
      //对于非空树，要找到先找到插入的位置
      SearchTreeNode* cur=*root;

      //把插入元素的父节点记录下来
      SearchTreeNode* pre=NULL;
      //此循环只是为了找到插入位置
      while(1)
      {
            if(cur==NULL)
            {
                //找到插入位置，跳出循环
                  break;
            }
            if(value<cur->data)
            {
                  pre=cur;
                  cur=cur->lchild;
            }
            else if(value>cur->data)
            {
                  pre=cur;
                  cur=cur->rchild;
            }
            else
            {
                  //发现有一个重复元素，则插入失败
                  return ;
            }
      }
      SearchTreeNode* new_node=SearchTreeCreateNode(value);
      //pre一定不为空，如果pre为空
      //意味着前面的while循环一进来就命中了：cur==NULL
      //然而cur为空，在最开始就排除了
      if(new_node->data<pre->data)
      {
            pre->lchild=new_node;
      }
      else if(new_node->data>pre->data)
      {
            pre->rchild=new_node;
      }
      return;


}

二叉搜索数的查找

这里写图片描述

SearchTreeNode* SearchTreeFind(SearchTreeNode* root, SearchTreeType to_find)
{
      if(root==NULL)
      {
            return ;
      }
      if(to_find<root->data)
      {
            //递归查找左子树
            return SearchTreeFind(root->lchild,to_find);
      }
      else if(to_find>root->data)
      {
            return SearchTreeFind(root->rchild,to_find);
      }
      return root;
}
//非递归

SearchTreeNode*  SearchTreeFind(SearchTreeNode* root,SearchTreeType value)
{
      if(root==NULL)
      {
            return NULL ;
      }
      SearchTreeNode* cur=root;
      while(cur!=NULL)
      {

            if(value<cur->data)
            {
                  cur=cur->lchild;
            }
            else if(value>cur->data)
            {
                  cur=cur->rchild;
            }
            else 
            {
                  break;
            }
      }
      return cur;
}

二叉搜索数的删除

（分三种情况进行处理）：

　　1.p为叶子节点，直接删除该节点，再修改其父节点的指针（注意分是根节点和不是根节点），如图a。

　　2.p为单支节点（即只有左子树或右子树）。让p的子树与p的父亲节点相连，删除p即可；（注意分是根节点和不是根节点）；如图b。

　　3.p的左子树和右子树均不空。找到p的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替p的值；或者方法二是找到p的前驱x，x一定没有右子树，所以可以删除x，并让x的父亲节点成为y的左子树的父亲节点。如图c。

//递归版本
void SearchTreeRemove(SearchTreeNode** root, SearchTreeType value)
{
      if(root==NULL)
      {
           //非法输入
            return ;
      }
      if(*root==NULL)
      {
           //空树
            return ;
      }
      //1.找到to_remove所在的位置
      SearchTreeNode* cur=*root;
      if(value<cur->data)
      {
           //递归删除左子树
            SearchTreeRemove(&cur->lchild,value);
            return ;
      }
      else if(value>cur->data)
      {
            //递归删除右子树
            SearchTreeRemove(&cur->rchild,value);
            return ;
      }
      //找到要删除元素，分情况讨论
      else
      {
           SearchTreeNode* to_remove_node=cur;
          //要删除的元素没有子树
           if(cur->lchild==NULL&&cur->rchild==NULL)
           {
                *root=NULL;
                DelNodeSearchTree(to_remove_node);
                return ;
           }
           //要删除的元素只有左子树
           else if(cur->lchild!=NULL&&cur->rchild==NULL)

           {
                 //把当前节点的左孩子托付给该点的父节点
                 *root=to_remove_node->lchild;
                 DelNodeSearchTree(to_remove_node);
                 return ;
           }
           else if(cur->lchild==NULL&&cur->rchild!=NULL)
           {
                 //把当前节点的右孩子托付给该点的父节点
                 *root=to_remove_node->rchild;
                 DelNodeSearchTree(to_remove_node);
                 return ;
           }
           //要删除的元素既有左子树，又有右子树
           {
                 //找到右子树中的最小节点
                 SearchTreeNode* min=to_remove_node->rchild;
                 while(min->lchild!=NULL)
                 {
                       min=min->lchild;
                       //循环结束，找到了最小节点
                 }
                 //将最小值覆盖要删除当前节点值
                 to_remove_node->data=min->data;
                 //尝试递归删除min->data
                 SearchTreeRemove(&to_remove_node->rchild,min->data);
                 return ;
           }

      }
      return ;
}
//非递归版本
void SearchTreeRemove(SearchTreeNode** root,SearchTreeType value)
{
      if(root==NULL)
      {
            return ;

      }
      if(*root==NULL)
      {
            return ;
      }
      //先找到要删除的节点是谁
      SearchTreeNode* to_remove_node=*root;
      //找到删除节点的父节点
      SearchTreeNode* pre=NULL;
      while(1)
      {
            if(to_remove_node==NULL)
            {
                //没找到要删除的元素，直接返回
                  return ;
            }
            //在左子树中查找
            if(value<to_remove_node->data)
            {
                  pre=to_remove_node;
                  to_remove_node=to_remove_node->lchild;

            }
            //在右子树上查找
            else if(value>to_remove_node->data)
            {

                  pre=to_remove_node;
                  to_remove_node=to_remove_node->rchild;
            }
            else
            {
                //找到了
                  break;
            }
      }
      //找到了，分四种情况讨论
      //没有子树
      if(to_remove_node->lchild==NULL&&to_remove_node->rchild==NULL)
      {
            //此处先判定删除节点是否是根节点
            if(to_remove_node==*root)
            {
                  //删除节点是根节点
                  *root=NULL;
            }
            else
            {

                //删除节点不是根节点
                if(to_remove_node->data<pre->data)
                {
                     pre->lchild=NULL; 
                }
                else 
                {
                      pre->rchild=NULL;
                }
            }
            //统一释放内存
            DelNodeSearchTree(to_remove_node);
            return ;

      }
      //只有左子树
      else if(to_remove_node->lchild!=NULL&&to_remove_node->rchild==NULL)
      {
          //删除节点是根节点
          if(*root=to_remove_node)
          {
                *root=to_remove_node;
          }
          //不是根节点
          else
          {
               //要删除节点是父节点的左子树
               if(to_remove_node->data<pre->data)
               {
                   //把当前节点的左子树托付给父节点的左子树（该点只有左子树，没有右子树） 
                     pre->lchild=to_remove_node->lchild;
               }
               //要删除节点是父节点的左子树
               if(to_remove_node->data<pre->data)
               {
                   //把当前节点的左子树托付给父节点的右子树 
                     pre->rchild=to_remove_node->lchild;
               }
          }
          DelNodeSearchTree(to_remove_node);
          return ;

      }
       //只有右子树
      else if(to_remove_node->lchild==NULL&&to_remove_node->rchild!=NULL)
      {
            //要删除元素是根节点
            if(*root==to_remove_node)
            {
                  *root=NULL;
            }
            //要删除元素不是根节点（只有右子树）
            else
            {
                  //要删除元素是父节点的左子树，则把要删除元素的右子树托付给父节点的左孩子
                  if(to_remove_node->data<pre->data)
                  {
                        pre->lchild=to_remove_node->rchild;
                  }
                  //要删除元素是父节点的右子树，则把要删除元素的右子树托付给父节点的右孩子
                  if(to_remove_node->data>pre->data)
                  {
                        pre->rchild=to_remove_node->rchild;
                  }
            }
            DelNodeSearchTree(to_remove_node);
            return ;
      }
      //既有左子树又有右子树
      else
      {
          SearchTreeNode* min=to_remove_node->rchild;
          SearchTreeNode* min_pre=to_remove_node;
          while(min->lchild!=NULL)
          {
                min_pre=min;
                min=min->lchild;
          }
          //循环结束，min就指向了to_remove_node右子树的最小值
          to_remove_node->data=min->data;
          if(min->data<min_pre->data)
          {
                //min 是min_pre的左子树
                //min一定没有左子树
                min_pre->lchild=min->rchild;

          }
          else
          {
                //通常情况下mins是min_pre的左子树
                //但是c初始情况下除外
                min_pre->rchild=min->rchild;

          }
          DelNodeSearchTree(min);
          return ;

      }
      return ;

}

搜索二叉树的销毁

void SearchTreeDestory(SearchTreeNode** root)
{
      if(root==NULL)
      {
            return ;
      }
      if(*root==NULL)
      {
            return ;
      }
      SearchTreeNode* cur=*root;
      SearchTreeDestory(&cur->lchild);
      SearchTreeDestory(&cur->rchild);
      DelNodeSearchTree(cur);
      //防止变成野指针
      *root=NULL;
      return ;

}

这里写图片描述

zgege
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构—二叉搜索树
Brain的博客
06-17 229
#数据结构—二叉搜索树 1.什么是树： 一种非线性的数据结构 一个结点只有一个父节点，零个或多个子节点；除了父节点以外每个结点只有一个父节点，并且兄弟结点不相： 结点的度：每个结点所拥有子树的数目； 兄弟结点：有相同父节点的结点； 树的度：最大度结点，的度叫做树的度； 树的深度：根到叶子节点的所连的边的数目， 数的高度：树的深度反过来； 树的层数：树的深度+1； 2.二叉树： 除了叶子节点以外，每...
二叉搜索树（数据结构）
weixin_61518137的博客
03-15 687
1.二叉搜索树的定义： 若它的左子树不为空，则左子树的所有结点的值都小于根结点的值； 若它的右子树不为空，则右子树的所有结点的值都大于根结点的值； 他的左右子树也是二叉搜索树 上代码： static class Node { int data; public Node(int data) { this.data=data; } Node left; Node right;
二叉搜索树（构造篇）
c630843901的博客
07-07 955
二叉搜索树（特性篇）讲了中序遍历对 BST 的重要意义,二叉搜索树（基操篇）写了 BST 的基本操作。本文循序渐进地讲两道题，如何计算所有有效 BST。力扣第 96 题「 不同的二叉搜索树」固定一个根节点后，其形状总数为左子树的组合数和右子树的组合数乘积 注意 base case，显然当闭区间肯定是个空区间，也就对应着空节点 null，虽然是空节点，但是也是一种情况，所以要返回 1 而不能返回 0。但是这样会出现很多重叠子问题，这时就需要备忘录来记录已经访问过的组合 当然这道题动态规划也可以解决 不同的二
数据结构——二叉搜索树
qq_42106610的博客
11-04 364
二叉搜索树的定义、性质及相关操作，分别用递归和非递归两种方法实现了插入、删除函数
数据结构之二叉搜索树
求知若渴！大智若愚！
04-18 737
纸上得来终觉浅，绝知此事要躬行 性质对于节点x 如果y是x的左孩子，则x.key>=y.keyx.key >= y.key 如果y是x的右孩子，则x.key<=y.keyx.key <= y.key 如图1： 查询操作 遍历操作：inorder-tree-walk(x)——中序, preorder-tree-walk(x)——先序,postorder-tree-walk(x)——后续 inorde
基于C语言的数据结构-二叉搜索树bitTree
06-25
二叉搜索树（Binary Search Tree，BST），也称为二叉排序树，是计算机科学中用于组织数据的一种数据结构。在二叉搜索树中，每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用以及一个指向右子节点的...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
c代码-二叉搜索树的查找操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，尤其是在数据检索方面。本主题将深入探讨如何使用C语言实现二叉搜索树的查找操作。 二叉搜索树的核心特点是每个...
【数据结构】二叉搜索树
最新发布
Shun_Hua的博客
07-31 565
主要讲解了搜索二叉树的概念和模拟实现……
构造二叉搜索树
ganlinczz的博客
02-14 497
视频学习地址 代码中树的结构如下图所示 #include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *lchild,* rchild; int ltag,rtag; }tree; tree get(char c); tree * pre = NULL; int main() { tree a = get('A'); tree b
PAT-A 1099 Build A Binary Search Tree (30 分)
qq_45682511的博客
12-02 149
二叉搜索树 (BST) 递归定义为具有以下属性的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值 若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值 它的左、右子树也分别为二叉搜索树 给定二叉树的具体结构以及一系列不同的整数，只有一种方法可以将这些数填充到树中，以使结果树满足 BST 的定义。 请你输出结果树的层序遍历。 输入格式 第一行包含一个正整数 N，表示树的结点个数。 所有结点的编号为 0∼N−1，并且编号为 0 的结点是根结点。 接下来 N 行，第 i 行（从
hdu3791（二叉搜索树构造）
Tworld
07-29 978
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3791 题目大意：给出若干行数列，其中第一行的数列为基本二叉搜索树的模式，剩下的数列都为需要比较的数列，若构造出的二叉搜索树与基本数列相同，则输出“YES”，否则输出“NO”； 解题思路：根据题目给出的数列构造二叉搜索树，然后循环遍历树，判断是否相等。因为题目较简单，实用数组进行简单的模拟，根据左子
二叉搜索树数据结构完整实现
HMC20071120015的专栏
10-02 1228
文章首发于此，BST是后面自平衡二叉树AVL树，B树等数据结构的基础，所以理解BST的基本性质和操作很有必要，如果读者对BST不是很了解可以查下wiki或者是参考严蔚敏的《数据结构与算法》或者《算法导论》，对于该数据结构有较详细解释，下面是我查询资料实现的Java版本。 package com.mars.search; public class BinarySeachTree { pr
数据结构（二）：二叉搜索树（Binary Search Tree）
mjiansun的专栏
04-11 1176
转自：数据结构（二）：二叉搜索树（Binary Search Tree） - 简书 (jianshu.com) 引子 定义 二叉搜索树是一种节点值之间具有一定数量级次序的二叉树，对于树中每个节点： 若其左子树存在，则其左子树中每个节点的值都不大于该节点值； 若其右子树存在，则其右子树中每个节点的值都不小于该节点值。 示例： 查询复杂度 观察二叉搜索树结构可知，查询每个节点需要的比较次数为节点深度加一。如深度为 0，节点值为 “6” 的根节点，只需要一次比较即可；深度为 1，节点
数据结构与算法之树（二）二叉查找树
JT同学的博客
09-16 481
数据结构之树 数据结构之树（一）二叉树概念及遍历方式（图文并茂） 数据结构之树（二）二叉查找树 数据结构之树（三）红黑树 数据结构之树（二）二叉查找树 文章目录数据结构之树（二）二叉查找树一、二叉查找树结构二、二叉查找树查找三、二叉查找树插入四、二叉查找树删除五、二叉查找树的不足 一、二叉查找树结构 二叉查找树的二叉树的一种常见类型，又可以称为二叉搜索树。顾名思义，二叉查找树支持快速的查找，不仅如...
数据结构-二叉排序树的删除算法解析
为了提高查找效率，通常会采用特定的结构来组织查找表，比如有序数组、链表、平衡二叉搜索树等。静态查找表通常使用顺序或链式结构，例如，给定的学生信息列表可以通过学号进行线性查找。但这种查找效率较低，尤其是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值