二叉排序树

最新推荐文章于 2023-10-01 10:41:33 发布
最新推荐文章于 2023-10-01 10:41:33 发布
阅读量845 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 二叉排序树 二叉查找树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yunzhongguwu005/article/details/9354565
版权

    二叉排序树又名二叉查找树，其定义如下:

  

 二叉树的定义如下:

//定义二叉查找树的节点
template<typename T>
struct TreeNode
{
	T key;
    TreeNode * lchild;
    TreeNode * rchild;
};

  二叉排序树的查找算法如下:

//在二叉树head中查找关键字为key的元素，
//若存在返回true,p指向该节点
//若不存在返回false,p指向该插入到的节点
template <typename T>
bool SearchBST(TreeNode<T> * head,T key,TreeNode<T> * f,TreeNode<T> * &p)
{
	//f指向T的双亲
   if(head==NULL)//查找不成功,最开始f为NULL
   {
     p=f;
	 return false;
   }
   else if(head->key==key)
   {
     p=head;
	 return true;
   }
   else if(key<head->key)
   {
    return SearchBST(head->lchild,key,head,p);
   }
   else
   {
    return SearchBST(head->rchild,key,head,p);
   }
}

//SearchBST的非递归实现
template <typename T>
bool SearchBST(TreeNode<T> * head,T key,TreeNode<T> * &p)
{
   TreeNode<T> * parent=NULL;
   TreeNode<T> * q=head;
   while(q!=NULL && q->key!=key)
   {
     parent=q;
     if(key<q->key)
		 q=q->lchild;
	 else
		 q=q->rchild;
   }
   if(q==NULL)//查找不成功
   {
      p=parent;
	  return false;
   }
   else//q!=NULL 查找成功 
   {
    p=q;
	return true;
   }
}
 

二叉排序树插入操作算法

//当二叉排序树head中不存在关键字为key的数据元素时,插入key返回true
template<typename T>
bool InsertBST( TreeNode<T> * & head,T key)
{
	TreeNode<T> * p;
	if(SearchBST(head,key,p)==false)
	{
      //开始创建一个节点
	  TreeNode<T> * node=new TreeNode<T>;
	  node->key=key;
	  node->lchild=NULL;
	  node->rchild=NULL;
      if(p==NULL)//如果开始树为空
		  head=node;
	  else
	  {
	   if(key<(p->key))
          p->lchild=node;
	   else
          p->rchild=node;
	  }
	  return true;
	}
	return false;
}
二叉排序树删除操作(二叉树的难点)

 

下面算法采用如下方法删除节点;

 1,若果p(要删除节点)的左子树为空,则令p的右子树成为p的双亲f的左子树或者右子树(根据p的key值与f的key值判断)。即用p的右子树代替p.

 2,若果p(要删除节点)的右子树为空,则令p的左子树成为p的双亲f的左子树或者右子树(根据p的key值与f的key值判断)。即用p的左子树代替p.

 3,如果p的左右子树都不为空,则找到二叉树中序遍历时p的直接前驱pre,用pre代替p。

    执行如下操作: (a):p->key=pre->key; (b) s->rchild=pre->lchild (s为pre的双亲) (c)删除s 

//删除关键字为key的元素(递归实现)
template<typename T>
bool DeleteBST(TreeNode<T> * &head,T key)
{
  if(!head)
	  return false;
  else
  {
	if(key==head->key)
      return DeleteBST(head);
	else if(key<head->key)
		return DeleteBST(head->lchild,key);
	else
		return DeleteBST(head->rchild,key);
  }
}

template <typename T>
bool DeleteBST(TreeNode<T> * &p)//执行实际的删除操作
{
   if(!(p->lchild))//p的左子树为空
   {
      TreeNode<T> * q=p;
	  p=p->rchild;
      delete q;
   }
   else if(!p->rchild)//p的右子树为空
   {
    TreeNode<T> * q=p;
	p=p->lchild;
	delete q;
   }
   else//p的左右子树都不为空
   {
     TreeNode<T> * q=p;//
	 //求p的直接前驱s
	 TreeNode <T> * s=p->lchild;
	 while(s->rchild)
	 {
	   q=s;//q记录s的父节点
	   s=s->rchild;
	 }
	 //用s代替p
	 p->key=s->key;
	 if(p!=q)
	   q->rchild=s->lchild;
	 else//p==q
	   q->lchild=s->lchild;
     delete s;
   }
   return true;
}

//删除关键字为key的元素(非递归实现)
template<typename T>
bool _DeleteBST(TreeNode<T> * &head,T key)
{
   TreeNode<T> * parent=NULL;//待删除节点的父节点 
   TreeNode<T> * p=head;//待删除的节点 
   while(p && p->key!=key)
   {
      parent=p;
	  if(key<p->key)
		  p=p->lchild;
	  else
		  p=p->rchild;
   }
   if(!p)
	   return false;//关键字为key的元素不存在
   //else存在
   if(!p->lchild)//p的左孩子不存在
   {
     if(!parent)//根节点即为p
       head=p->rchild;
	 else
	 {
       if(p->key<parent->key)
		   parent->lchild=p->rchild;
	   else
		   parent->rchild=p->rchild;
	 }
   }
   else if(!p->rchild)//p的右孩子不存在
   {
     if(!parent)
        head=p->lchild;
	 else
	 {
		 if(p->key<parent->key)
			 parent->lchild=p->lchild;
		 else
			 parent->rchild=p->lchild;
	 }
   }
   else //p的左右孩子都存在
   {
	   //计算p的中序遍历的前驱pre
	   TreeNode<T> * pre=p->lchild;//待删除节点中序遍历的直接前驱节点
	   TreeNode<T> * q=p;//直接前驱节点的父节点 
	   while(pre->rchild)
	   {
		   q=pre;
		   pre=pre->rchild;
	   }
	   p->key=pre->key;
	   if(q!=p)
		   q->rchild=pre->lchild;
	   else
		   q->lchild=pre->lchild;

       p=pre;
   }
   delete p;
   return true;
}

总体代码如下: 

// 二叉查找树
#include "stdafx.h"
#include <iostream>
using namespace std;

//定义二叉查找树的节点
template<typename T>
struct TreeNode
{
	T key;
    TreeNode * lchild;
    TreeNode * rchild;
};

//在二叉树head中查找关键字为key的元素，
//若存在返回true,p指向该节点
//若不存在返回false,p指向该插入到的节点
template <typename T>
bool SearchBST(TreeNode<T> * head,T key,TreeNode<T> * f,TreeNode<T> * &p)
{
	//f指向T的双亲
   if(head==NULL)//查找不成功,最开始f为NULL
   {
     p=f;
	 return false;
   }
   else if(head->key==key)
   {
     p=head;
	 return true;
   }
   else if(key<head->key)
   {
    return SearchBST(head->lchild,key,head,p);
   }
   else
   {
    return SearchBST(head->rchild,key,head,p);
   }
}

//SearchBST的非递归实现
template <typename T>
bool SearchBST(TreeNode<T> * head,T key,TreeNode<T> * &p)
{
   TreeNode<T> * parent=NULL;
   TreeNode<T> * q=head;
   while(q!=NULL && q->key!=key)
   {
     parent=q;
     if(key<q->key)
		 q=q->lchild;
	 else
		 q=q->rchild;
   }
   if(q==NULL)//查找不成功
   {
      p=parent;
	  return false;
   }
   else//q!=NULL 查找成功 
   {
    p=q;
	return true;
   }
} 
 
//当二叉排序树head中不存在关键字为key的数据元素时,插入key返回true
template<typename T>
bool InsertBST( TreeNode<T> * & head,T key)
{
	TreeNode<T> * p;
	if(SearchBST(head,key,p)==false)
	{
      //开始创建一个节点
	  TreeNode<T> * node=new TreeNode<T>;
	  node->key=key;
	  node->lchild=NULL;
	  node->rchild=NULL;
      if(p==NULL)//如果开始树为空
		  head=node;
	  else
	  {
	   if(key<(p->key))
          p->lchild=node;
	   else
          p->rchild=node;
	  }
	  return true;
	}
	return false;
}


//删除关键字为key的元素(递归实现)
template<typename T>
bool DeleteBST(TreeNode<T> * &head,T key)
{
  if(!head)
	  return false;
  else
  {
	if(key==head->key)
      return DeleteBST(head);
	else if(key<head->key)
		return DeleteBST(head->lchild,key);
	else
		return DeleteBST(head->rchild,key);
  }
}

template <typename T>
bool DeleteBST(TreeNode<T> * &p)//执行实际的删除操作
{
   if(!(p->lchild))//p的左子树为空
   {
      TreeNode<T> * q=p;
	  p=p->rchild;
      delete q;
   }
   else if(!p->rchild)//p的右子树为空
   {
    TreeNode<T> * q=p;
	p=p->lchild;
	delete q;
   }
   else//p的左右子树都不为空
   {
     TreeNode<T> * q=p;//
	 //求p的直接前驱s
	 TreeNode <T> * s=p->lchild;
	 while(s->rchild)
	 {
	   q=s;//q记录s的父节点
	   s=s->rchild;
	 }
	 //用s代替p
	 p->key=s->key;
	 if(p!=q)
	   q->rchild=s->lchild;
	 else//p==q
	   q->lchild=s->lchild;
     delete s;
   }
   return true;
}

//删除关键字为key的元素(非递归实现)
template<typename T>
bool _DeleteBST(TreeNode<T> * &head,T key)
{
   TreeNode<T> * parent=NULL;//待删除节点的父节点 
   TreeNode<T> * p=head;//待删除的节点 
   while(p && p->key!=key)
   {
      parent=p;
	  if(key<p->key)
		  p=p->lchild;
	  else
		  p=p->rchild;
   }
   if(!p)
	   return false;//关键字为key的元素不存在
   //else存在
   if(!p->lchild)//p的左孩子不存在
   {
     if(!parent)//根节点即为p
       head=p->rchild;
	 else
	 {
       if(p->key<parent->key)
		   parent->lchild=p->rchild;
	   else
		   parent->rchild=p->rchild;
	 }
   }
   else if(!p->rchild)//p的右孩子不存在
   {
     if(!parent)
        head=p->lchild;
	 else
	 {
		 if(p->key<parent->key)
			 parent->lchild=p->lchild;
		 else
			 parent->rchild=p->lchild;
	 }
   }
   else //p的左右孩子都存在
   {
	   //计算p的中序遍历的前驱pre
	   TreeNode<T> * pre=p->lchild;//待删除节点中序遍历的直接前驱节点
	   TreeNode<T> * q=p;//直接前驱节点的父节点 
	   while(pre->rchild)
	   {
		   q=pre;
		   pre=pre->rchild;
	   }
	   p->key=pre->key;
	   if(q!=p)
		   q->rchild=pre->lchild;
	   else
		   q->lchild=pre->lchild;

       p=pre;
   }
   delete p;
   return true;
}

//中序遍历二叉查找树
template <typename T>
void printBST(TreeNode<T> * head)
{
   if(head==NULL)
	   return ;
   printBST(head->lchild);
   cout<<head->key<<" ";
   printBST(head->rchild);
}

int _tmain(int argc, _TCHAR* argv[])
{
	TreeNode<int> * head=NULL;
	TreeNode<int> * p=NULL;
	
    InsertBST(head,45);
    InsertBST(head,24);
	InsertBST(head,53);
	InsertBST(head,45);
	InsertBST(head,12);
	InsertBST(head,24);
	InsertBST(head,90);
	printBST(head);//构造的二叉树如下图所示
	cout<<endl;
	//SearchBST(head,10,(TreeNode<int> *)NULL,p);
	cout<<SearchBST(head,12,p)<<endl;
	_DeleteBST(head,24);
	printBST(head);
	system("PAUSE");
	return 0;
}

本文参考 数据结构（C语言版 严蔚敏) 9.21节


云中孤鹜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉排序树的实现与基本操作
08-31
二叉排序树又称二叉查找树。本文主要对二叉排序树的实现与基本操作进行详细介绍，以下代码实现了：1、二叉树的构建；2、二叉树的中、前、后、层序遍历；3、二叉树中结点的最大距离。下面就跟着小编一起来看下吧
数据结构-二叉排序树（图文详细版）
淡沫初夏zz的博客
01-17 5万+
二叉排序树
数据结构-----二叉排序树
m0_73633088的博客
10-01 6496
今天我们继续学习新的知识点----排序二叉树，在此之前我们学习了相关的排序算法，给你一个数组，然后对这个数组进行排序。那么同样的我们也可以去构建一个二叉排序树，在创建树的过程中进行排序，也能实现排序的效果，下面就一起来看看吧！二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。给定一个二叉树，如果满足以下条件，那就是二叉排序树。
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 7万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
数据结构-二叉排序树（BST树）
理科男同学
11-15 8889
1，二叉排序树介绍 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树又分别为二叉排序树。 显然二叉排序树的定义是一个递归形式的定义，所以后面景禹要讲的插入、查找和删除都是基于递归的形式。特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 1.1，二叉排序树的构建 假设我们有初始的无序...
二叉排序树详解
云杉木屋
04-01 2万+
摘要：本篇笔记专门介绍二叉排序树，重点讲解了二叉排序树的特性，以及二叉排序树各方面的基本实现。
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
1.构造一棵二叉排序树并对其进行中序遍历输出；2．在二叉排序树中查找某一关键字，若存在，显示查找成功；若不存在，将其插入到二叉排序树中，再中序遍历输出。
详解数据结构——二叉排序树
莫浅子的博客
10-29 1万+
二叉排序树，又称二叉查找树（BST，Binary Search Tree)一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树: 左子树上所有结点的关键字均小于根结点的关键字; 右子树上所有结点的关键字均大于根结点的关键字。左子树和右子树又各是一棵二叉排序树 左子树结点值
数据结构之二叉排序树（C语言实现）
kang___xi的博客
05-21 7万+
一、基本概念 1.二叉排序树 二叉排序树（Binary sort tree，BST），又称为二叉查找树，或者是一棵空树；或者是具有下列性质的二叉树： (1)若它的左子树不为空，则左子树上所有节点的值均小于它的根节点的值； (2)若它的右子树不为空，则右子树上所有节点的值均大于它的根节点的值； (3)它的左、右子树也分别为二叉...
数据结构（34）二叉排序树
李白
06-20 9674
目录 1、二叉排序树（BST,Binary Sort Tree）定义 2、二叉排序树的查找 3、二叉排序树的插入 4、二叉排序树的构造 6、二叉排序树的查找效率分析 7、二叉排序树与二分排序对比 1、二叉排序树（BST,Binary Sort Tree）定义 二叉排序树（也称为二叉查找树）或者是一棵空树，或者是具有以下特性的二叉树： 1）若左子树非空，则左子树上所有结点的值均小于根节点的值。 2）若右子树非空，则右子树上所有结点的值均大于根节点的值。 3）左、右子树也分别是一棵二叉排序
二叉排序树Binary sort tree（BST）
xiaobai_hellow的博客
03-06 1万+
二叉搜索树（BST）1.二叉搜索树的概念2.二叉搜索树的操作及应用3.二叉搜索树的模拟实现 1.二叉搜索树的概念 二叉排序数也叫二叉搜索树，有以下特点： ①：二叉搜索树的左节点永远小于父节点。 ②：二叉搜索树的右节点永远大于父节点。 ③：它的左右子树也分别为二叉搜索树 2.二叉搜索树的操作及应用 二叉搜索树本质还是二叉树，只是对节点各种需求有了不同的方式。 1.名字叫二叉搜索树，那么其查找方式肯定很棒 由于它的特点，当树不为空的时候，我们只需要去比较要搜索的值与各个节点的值，如果大于该节点，那么就在该节点的
二叉排序树(BST)--构造二叉排序树
today2222的博客
09-13 4323
已知一个有序序列，如何构造一个二叉排序树呢？
详解二叉排序树
myblog
07-17 2万+
二叉排序树的插入、查找、删除 二叉排序树的定义 二叉排序树右称二叉查找树。或者为空树，或者是具有以下性质： （1）若它的左子树不为空，则左子树所有节点的值小于根结点， （2）若它的右子树不为空，则根结点的值小于所有右子树结点的值 （3）它的左右子树叶分别为二叉排序树 总结起来就是根据结点的值有：左子树根结点右子树 如下图就是一棵二叉排序树 它的中序遍历：1
二叉排序树，看完你就会了
jsphpyyds的博客
08-15 3309
二叉排序树又称“二叉搜索树”，是一种左子树比根结点小，右子树比根结点大的特殊二叉树的形式；因为其排序的特殊性，所以在查找某个结点的时候可以遵循某种规律，因此其查找算法相较普通的二叉树效率高的不止一点点；而实际开发中使用了二叉树这种数据结构的，大部分都是二叉排序树，因此掌握它，尤为重要！ 一、认识二叉排序树 二叉排序树，需要左子树小于根结点，右子树大于根结点，很显然上面两图都不满足条件。 来看看下面这张图，没错，他就是二叉排序树： 二、初始化二叉排序树 仔细观察二叉排序树的结构...
二叉排序树（BST）
荒唐的博客
11-11 5388
二叉排序树的定义 查找操作 插入操作 删除操作 查找效率分析——平均查找长度ASL 平衡二叉树（二叉排序树的引申概念） 二叉排序树的定义 二叉排序树，又称二叉查找树（BST，Binary Search Tree） 一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树： 1、左子树上所有结点的关键字均小于根结点的关键字； 2、右子树上所有结点的关键字均大于根结点的关键字。 左子树与右子树各是一棵二叉排序树。 左子树结点值<根结点值<右子树结点值 如果对二叉排序树进行中序
二叉排序树的常见操作和算法的设计与实现 (1）二叉排序树的创建 2）二叉排序树中增加和删除关键字 3）判别是否是二叉排序树 (4）二叉排序树的最大值和第k大的值
最新发布
12-27
以下是二叉排序树的常见操作和算法的设计与实现： 1. 二叉排序树的创建： - 创建一个空的二叉排序树。 - 依次将关键字插入到二叉排序树中，插入时需要保持二叉排序树的性质：左子树的关键字小于根节点的关键字，右子树的关键字大于根节点的关键字。 2. 二叉排序树中增加和删除关键字： - 增加关键字：将关键字插入到二叉排序树中，插入时需要保持二叉排序树的性质。 - 删除关键字：首先在二叉排序树中查找要删除的关键字，如果找到了，则有以下几种情况： - 如果要删除的节点是叶子节点，直接删除即可。 - 如果要删除的节点只有一个子节点，将子节点替换到要删除的节点的位置。 - 如果要删除的节点有两个子节点，可以选择用其前驱或后继节点替换，然后再删除前驱或后继节点。 3. 判别是否是二叉排序树： - 对于一个二叉树，如果它满足以下条件，则可以判别为二叉排序树： - 左子树的所有节点的关键字小于根节点的关键字。 - 右子树的所有节点的关键字大于根节点的关键字。 - 左子树和右子树也都是二叉排序树。 4. 二叉排序树的最大值和第k大的值： - 最大值：二叉排序树的最大值即为最右边的叶子节点或者最右边的子树的根节点。 - 第k大的值：可以通过中序遍历二叉排序树得到一个递增的有序序列，然后取第k个元素即为第k大的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值