【数据结构】二叉搜索树

最新推荐文章于 2019-03-26 15:58:03 发布
最新推荐文章于 2019-03-26 15:58:03 发布
阅读量793 收藏
点赞数
分类专栏： 数据结构 c/c++ 文章标签： 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peiyao456/article/details/52900104
版权

二叉搜索树，又叫二叉排序树，二叉查找树。它有以下特点：

左子树的值小于根节点的值，右子树的值大于根节点的值；二叉搜索树中序遍历的结果

就是一个升序序列。

当然，空树也是一个二叉搜索树。

全局满足二叉搜索树的性质，局部也应该满足。

既然有以上性质，那么二叉树的查找是相当方便的，当然插入和删除，复杂度也会明显

降低。

查找：从根节点开始，如果要插入的key小于根节点的key，则向左走，否则向右走，找

到了直接返回，如果已经走到空了，还没找到，说明要查找的key不存在。下边给出实现

代码：

bool FindNonR(const K& key)
	{
		if (NULL == _root)
			return false;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
				return true;
		}
		return false;
	}


递归版本比较简单，这里就不给出实现了。

插入：找到合适的空位置，插入元素，如果要插入的值，在原来的搜索二叉树中已将存

在则不能进行插入。下边画图说明：


根据上边的图解，写出如下代码：

bool InsertNonR(const K& key)
	{
		if (NULL == _root)//空树
		{
			_root = new Node(key);
			return true;
		}
		//不是空树
		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else//已经存在的值
			{
				return false;
			}
		}
		Node* NewNode = new Node(key);
		if (key < parent->_key)
			 parent->_left = NewNode ;
		else
			parent->_right = NewNode;
		return true;
	}


从上边的图中，我们可以看出，插入元素必须记住父节点，否则无法实现连接操作。

二叉搜索树也可以递归实现：下边给出实现代码：

bool _InsertR(Node*& root, const K& key)
	{
		if (root == NULL)
		{
			root = new Node(key);
			return true;
		}
		Node* cur = root;
		if (cur->_key < key)
		{
			_InsertR(cur->_right,key);
		}
		else if (cur->_key > key)
		{
			_InsertR(cur->_left, key);
		}
		else
			return false; 
	}



这段代码中，我们可以看出：形参中我们采用的是引用传参，这样巧妙的利用了引用的

性质：变量的别名，两者同时被修改。

当原来的树就是空树（_root == NULL），root的改变就直接影响了_root的改变；

当原来的树中已经有一些元素,（利用上图的例子，插入3）

（前边一些查找步骤省略）4的left是空，走到函数第一个if，创建一个新的结点，连在

root上，此时的root是4的left的别名，所以两者都改变了，起到了连接的作用。

删除：找到要删除的元素，进行删除，这个比较复杂，图解：


下边给出代码实现：

bool RemoveNonR(const K& key)
	{
		if (NULL == _root)
			return false;
		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				Node* del = NULL;
				//叶子节点直接删除
				if (cur->_left == NULL && cur->_right == NULL)
				{
					if (parent && cur == parent->_left)
					{
						parent->_left = NULL;
						del = cur;
					}

					else if (parent && cur == parent->_right)
					{
						parent->_right = NULL;
						del = cur;
					}
					else
					{
						del = cur;
						_root = NULL;
					}
				}
				//只有一个孩子的结点
				else if (cur->_left == NULL || cur->_right == NULL)
				{
					//只有左孩子
					if (cur->_left != NULL)
					{
						if (parent == NULL)
						{
							_root = parent->_left;
							del = cur;
						}
						else if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					//只有右孩子
					else
					{
						if (parent == NULL)
						{
							_root = cur->_right;
							del = cur;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
						else//cur是parent的左孩子
						{
							parent->_left = cur->_right;
						}
					}
				}
				else//有两个孩子的结点
				{
					Node* tmp = cur->_right;//查找右子树的最左结点
					while (tmp && tmp->_left)
					{
						parent = tmp;
						tmp = tmp->_left;
					}
					swap(cur->_key,tmp->_key);
					//删除tmp结点
					//tmp是叶子节点 ，tmp只有一个孩子结点
					if (tmp == parent->_left)
					{
						parent->_left = tmp->_right;
					}
					else
					{
						parent->_right = tmp->_right;
					}
					del = tmp;
				}
				delete del;
				del = NULL;
				return true;
			}
		}
		//没有找到要删除的值
		return false;
	}


对于删除操作，也可以用递归实现：

代码：

bool _RemoveR(Node*& root,const K& key)
	{
		if (root == NULL)
			return false;
		
		if (root->_key < key)
		{
			_RemoveR(root->_right,key);
		}
		else if (root->_key > key)
		{
			_RemoveR(root->_left,key);
		}
		else
		{
			Node* del = root;
			Node* parent = root;
			if (root->_left == NULL)//仅有右孩子
			{
				root = root->_right;
			}
			else if (root->_right ==NULL)
			{
				root = root->_left;
			}
			else
			{
				Node* minRight = root->_right;
				//找右子树的最左结点
				while (minRight->_left)
				{
					parent = minRight;
					minRight = minRight->_left;
				}
				root->_key = minRight->_key;

				if (minRight == parent->_right)
				{
					parent->_right = minRight->_right;
				}
				else
				{
					parent->_left = minRight->_right;
				}
				del = minRight;
			}
			delete del;
		}
		return true;
	}


这段代码中，找要删除的结点是递归操作。找到之后，如果该节点只有一个孩子或者没

有孩子，直接将指向当前结点的指针指向其孩子结点或者空，利用引用，很好的连接了

起来。如果当前结点有左右孩子，利用非递归中的处理办法解决。

【完整代码】

#pragma once
#include<iostream>
using namespace std;
#include<stack>

template<typename K>
struct SearchBinaryTreeNode
{
	K _key;
	SearchBinaryTreeNode<K>* _left;
	SearchBinaryTreeNode<K>* _right;
	SearchBinaryTreeNode(const K& key)
		:_key(key)
		,_left(NULL)
		,_right(NULL)
	{}
};

template<typename K>
class SearchBinaryTree
{
	typedef SearchBinaryTreeNode<K> Node;
public:
	SearchBinaryTree()
		:_root(NULL)
	{}

	void InorderNonR()
	{
		_InorderNonR(_root);
	}
	void InsertR(const  K& key)
	{
		_InsertR(_root,key);
	}

	void InOrderR()
	{
		_InOrderR(_root);
		cout << endl;
	}

	void RemoveR(const K& key)
	{
		_RemoveR(_root,key);
	}
	bool RemoveNonR(const K& key)
	{
		if (NULL == _root)
			return false;
		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				Node* del = NULL;
				//叶子节点直接删除
				if (cur->_left == NULL && cur->_right == NULL)
				{
					if (parent && cur == parent->_left)
					{
						parent->_left = NULL;
						del = cur;
					}

					else if (parent && cur == parent->_right)
					{
						parent->_right = NULL;
						del = cur;
					}
					else
					{
						del = cur;
						_root = NULL;
					}
				}
				//只有一个孩子的结点
				else if (cur->_left == NULL || cur->_right == NULL)
				{
					//只有左孩子
					if (cur->_left != NULL)
					{
						if (parent == NULL)
						{
							_root = parent->_left;
							del = cur;
						}
						else if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					//只有右孩子
					else
					{
						if (parent == NULL)
						{
							_root = cur->_right;
							del = cur;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
						else//cur是parent的左孩子
						{
							parent->_left = cur->_right;
						}
					}
				}
				else//有两个孩子的结点
				{
					Node* tmp = cur->_right;//查找右子树的最左结点
					while (tmp && tmp->_left)
					{
						parent = tmp;
						tmp = tmp->_left;
					}
					swap(cur->_key,tmp->_key);
					//删除tmp结点
					//tmp是叶子节点 ，tmp只有一个孩子结点
					if (tmp == parent->_left)
					{
						parent->_left = tmp->_right;
					}
					else
					{
						parent->_right = tmp->_right;
					}
					del = tmp;
				}
				delete del;
				del = NULL;
				return true;
			}
		}
		//没有找到要删除的值
		return false;
	}
	bool FindNonR(const K& key)
	{
		if (NULL == _root)
			return false;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
				return true;
		}
		return false;
	}

	bool InsertNonR(const K& key)
	{
		if (NULL == _root)//空树
		{
			_root = new Node(key);
			return true;
		}
		//不是空树
		Node* cur = _root;
		Node* parent = NULL;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else//已经存在的值
			{
				return false;
			}
		}
		Node* NewNode = new Node(key);
		if (key < parent->_key)
			 parent->_left = NewNode ;
		else
			parent->_right = NewNode;
		return true;
	}
protected:
	bool _RemoveR(Node*& root,const K& key)
	{
		if (root == NULL)
			return false;
		
		if (root->_key < key)
		{
			_RemoveR(root->_right,key);
		}
		else if (root->_key > key)
		{
			_RemoveR(root->_left,key);
		}
		else
		{
			Node* del = root;
			Node* parent = root;
			if (root->_left == NULL)//仅有右孩子
			{
				root = root->_right;
			}
			else if (root->_right ==NULL)
			{
				root = root->_left;
			}
			else
			{
				Node* minRight = root->_right;
				//找右子树的最左结点
				while (minRight->_left)
				{
					parent = minRight;
					minRight = minRight->_left;
				}
				root->_key = minRight->_key;

				if (minRight == parent->_right)
				{
					parent->_right = minRight->_right;
				}
				else
				{
					parent->_left = minRight->_right;
				}
				del = minRight;
			}
			delete del;
		}
		return true;
	}
	void _InOrderR(Node* root)
	{
		if (root == NULL)
			return;
		_InOrderR(root->_left);
		cout << root->_key << " ";
		_InOrderR(root->_right);
	}
	bool _InsertR(Node*& root, const K& key)
	{
		if (root == NULL)
		{
			root = new Node(key);
			return true;
		}
		Node* cur = root;
		if (cur->_key < key)
		{
			_InsertR(cur->_right,key);
		}
		else if (cur->_key > key)
		{
			_InsertR(cur->_left, key);
		}
		else
			return false; 
	}
	void _InorderNonR(Node* root)
	{
		if (NULL != root)
		{
			Node* cur = root;
			stack<Node*> s;
			while (cur || !s.empty())
			{
				while (cur)
				{
					s.push(cur);
					cur = cur->_left;
				}
				Node* top = s.top();
				s.pop();
				cout << top->_key << " ";
				cur = top->_right;
			}
		}
		cout << endl;
	}
private:
	Node* _root;
};
void TestBinaySearchNonR()
{
	SearchBinaryTree<int> bs;
	//int array[] = { 2,4,1,3,6,5 };
	int array[] = {5,3,4,1,7,8,2,6,0,9};
	for (size_t i = 0; i < 10; ++i)
	{
		bs.InsertNonR(array[i]);
	}
	bs.InorderNonR();
	bs.FindNonR(3);

	bs.RemoveNonR(0);
	bs.InorderNonR();
	bs.RemoveNonR(1);
	bs.RemoveNonR(2);
	bs.RemoveNonR(3);
	bs.RemoveNonR(4);
	bs.RemoveNonR(5);
	bs.RemoveNonR(6);
	bs.RemoveNonR(7);
	bs.RemoveNonR(8);
	bs.RemoveNonR(9);
	bs.InorderNonR();
}

void TestBinaySearchR()
{
	SearchBinaryTree<int> bs;
	int array[] = { 5,3,4,1,7,8,2,6,0,9 };
	for (size_t i = 0; i < 10; ++i)
	{
		bs.InsertR(array[i]);
	}
	bs.InOrderR();
	cout <<bs.FindNonR(3)<<endl;
	bs.RemoveR(0);
	bs.InorderNonR();
	bs.RemoveR(1);
	bs.RemoveR(2);
	bs.RemoveR(3);
	bs.InorderNonR();
	bs.RemoveR(4);
	bs.RemoveR(5);
	bs.RemoveR(6);
	cout << bs.FindNonR(3) << endl;
	bs.RemoveR(7);
	bs.RemoveR(8);
	bs.RemoveR(9);
	bs.InOrderR();
}


二叉搜索树的实现就到这里~~~

peiyao456
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CCCC-L3-016. 二叉搜索树的结构
flx413的博客
03-18 803
L3-016. 二叉搜索树的结构时间限制400 ms内存限制65536 kB代码长度限制8000 B判题程序Standard作者陈越二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科）给定一系列互不相等的整数，将它们顺次插...
[数据结构]二叉搜索树
Cipher的博客
09-13 118
二叉查找树性质：对于数中的每个节点X，其左子树中所有关键字值小于X关键字值，而其右子树所有关键字值大于X的关键字值 二叉查找树的创建，查找，插入，删除： struct TreeNode; typedef struct TreeNode *Position; typedef struct TreeNode *SearchTree; SearchTree MakeEmpty(SearchTree Tree); Position Find(ElementType X,SearchTree Tree); Po.
二叉搜索树的结构（30 分）
HHHHHHep的博客
11-13 2818
二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科） 给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确。例如将{ 2 4 1 3 0 }插入后，
二叉搜索树的结构 解题报告
NCC__dapeng的博客
03-26 655
二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科） 给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确。例如将{ 2 4 1 3 0 }插入后，...
数据结构-----二叉搜索树
aaronlanni的博客
01-27 221
一、基本概念 1、二叉搜索树概念 二叉搜索树：又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树 （1）若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 （2）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 （3）它的左右子树也分别为二叉搜索树 2、形式 二、操作 （一）插入 1、若二叉树为空——>直接插入 2、不为空 （1）找插入结点的位
数据结构 二叉搜索树
08-06
二叉搜索树（Binary Search Tree，BST）是数据结构领域中的一个重要概念，它是一种特殊的二叉树，每个节点都满足以下性质：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都...
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
数据结构案例：二叉搜索树（Binary Search Tree, BST）.docx
最新发布
07-17
数据结构案例：二叉搜索树（Binary Search Tree, BST）.docx 数据结构案例：二叉搜索树（Binary Search Tree, BST）.docx 数据结构案例：二叉搜索树（Binary Search Tree, BST）.docx 数据结构案例：二叉搜索树...
二叉搜索树实例练习
09-05
总结来说，二叉搜索树是一种高效的数据结构，特别适合于需要快速查找、插入和删除操作的场景。通过掌握其基本性质和操作，我们可以解决如判断序列是否对应相同二叉搜索树等实际问题。在编程实践中，理解二叉搜索树的...
Python中的模块学习之mock模块
热门推荐
天涯海角
08-10 2万+
学习Python也有一段时间了，然而对Python中的单元测试模块这些并不是很懂，刚好，今天有点时间，就将mock模块进行学习并整理，下边进行分享：先来看一下本文的整体框架： 为什么要使用mock？ 场景模拟1：比如有A和B两个模块，A模块中有调用到B模块的方法，但是很不幸，B模块中被A模块调用的方法由于一定的原因需要被修改，然而我们又不想让影响A模块的功能测试，所以就用到了单元测试模块unit
详解c++中类的六个默认的成员函数
天涯海角
07-06 1万+
类的6个默认的成员函数包括： 构造函数、析构函数、拷贝构造函数、赋值运算符重载函数、取地址操作符重载、const 修饰的取地址操作符重载。 （一）构造函数 构造函数，顾名思义，为对象分配空间，进行初始化。它是一种特殊的成员函数，具有以 下特点
如何判断一棵二叉树是否是完全二叉树
天涯海角
11-13 1万+
初次学习二叉树这种数据结构的时候，我们知道，假如一棵二叉树的高度是h，对于一棵完全二叉树，它的前h-1行一定是满的，第h行可以满也可以不满（结点必须集中于最后一行的左边），如果满则是满二叉树，不满的就是完全二叉树。概念描述不是很清晰~下边画图说明吧。 那么知道这些概念之后，我们要如何判断一棵二叉树是否是完全二叉树？？？ 1）如果一个结点有右孩子而没有左孩子，那么这棵树一定不是完全二叉
【操作系统】学习笔记（三）基于时间片轮转的进程调度算法
天涯海角
11-23 7394
本文主要用来分享基于时间片轮转的进程调度算法，但是在分享之前，我还是先来整理一下关于进程调度的基本理论。  调度是决定或者安排事物发展次序的策略。进程的调度就是决定哪个进程来使用处理机。 操作系统的3级调度： 1.作业调度，又叫高级调度。决定将外存上的哪些作业调到内存的就绪队列，等待执行。 2.进程调度，又叫低级调度，决定就绪队列中的哪个进程将获得处理机。 3.交换调度，又叫中级调度，为
排序算法（五）快速排序多种版本
天涯海角
11-22 7168
快速排序 ，就像它的名称一样，是时间复杂度比较低的一种排序算法。      我们知道，快速排序是通过分治的方法，将一个大的区间划分成小区间（找一个枢纽，将大的数放置在枢纽的右边，小的数放置在枢纽左边），然后对左右的两个小区间进行排序的过程。所以，快速排序的主要就是将区间进行划分，也就是单趟排序。单趟排序有以下的几种方法： 注明：以下3种方法中的GetMidNum()，下文予以解释~ 1.左
二叉树面试题--已知二叉树的两种遍历序列，求出另一种遍历序列
天涯海角
09-26 6176
已知先序遍历序列和中序遍历序列，求出后序序列   或者   已知中序序列和后序序列 ， 求出先序遍历。。都是一些考试中容易考的题目。 经过研究发现，已知先序序列和后序序列，无法唯一确定一棵树，所以就无法得知中序 序列。 下边给出例题： 一、已知先序和中序，求出后序。 下边再举一个例子，如下图： 通过上边两个例子的学习，对这种题目有了一定的理解，下边举例已知中序和后序，
顺序表的实现
天涯海角
06-04 6146
一直对顺序表的概念不是很清楚，终于在一次的学习中，明白了以下（红色标注）：         线性表是一种最简单、最基础的数据结构，线性表中的元素都是一对一的，除了第 一个元素和最后一个元素之外，其他元素都是首尾相接。通俗地讲，线性表中的元素都 是连在一条线中的，不管是直线还是曲线。如果是直线，我们称这个线性表为顺序表； 如果是曲线，我们称其为链表。 本篇文章，我来主要整理出关于顺序表的内
排序算法（四）选择排序及优化版本
天涯海角
11-20 5871
选择排序，是通过每次选择最小的数或者最大的数，然后将它放在它应该出现的位置上。 具体实现过程：将0号下标的数据保存，在之后的数中选择一个最小的数，如果最小的数不是0号数，则将最小的数与0号下标的数进行交换；将1号下标的数进行保存，在之后的数中 选择最小的数，如果最小的数不是1号数，进行交换。以此类推。 下边给出实现代码：void SelectSort(vector<int>& v) {
动态分配，结构，联合
天涯海角
05-15 5263
（一）动态内存分配： 1.为什么要动态内存分配呢？比如，我要做一个学生成绩管理系统，这里可能需要存储每个班级所有学生的信息，但 是，我们到底要分配多大的空间呢？？每个班的人数有可能并不相等，按多分配 ，那样多浪费；按少分配，不够。所以 动态内存分配就有自己的作用了~~ 2.动态内存分配函数： （1）void *malloc(unsigned  int  size);-------size
多版本通讯录
天涯海角
05-21 4564
开始写通讯录已经好久了，才把通讯录的多个版本整理完，下边我来谈谈实现通讯录过程中的一些问题，以及自己的心 得，另外附加代码。 通讯录要求：       1.增加信息   2.删除信息    3.查找信息  4.修改信息           5.显示信息   6.清除信息  7.按姓名排序  0.退出 我觉得，写代码之前一定要想清楚自己要实现的功能，应该怎么实现，大致应该清楚这些。 首先
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左子树所有节点的关键值（键值）小于根节点的关键值，而右子树所有节点的关键值大于根节点的关键值。AVL树则是一种自平衡的二叉搜索树，它保证...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值