WHCSRL 技术网

【数据结构】——二叉搜索树

目录

前言

二叉搜索树的概念

二叉搜索树的操作

 树的节点实现

 搜索树的基本结构

插入数据

查找

删除

拷贝构造函数

  二叉搜索树的应用

前言

在c++中的容器里map和set的学习需要二叉搜索树的铺垫，也为后边的的红黑树和AVL树做铺垫，也就是说，今天主要讲搜索树的基本结构和应用。

二叉搜索树的概念

所有的根节点大于左子树的节点，小于右子树的节点的二叉树就叫做二叉搜索树。

二叉搜索的性质：

  • 如果左子树不为空，则左子树上的所有节点都小于根节点。
  • 如果右子树不为空，则右子树上的所有节点都大于根节点。
  • 左右子树也为搜索二叉树。

 假设我们要查找8，我们从根节点开始查找，这该怎样查找呢？

首先我们先与根节点5对比，发现比根节点5大，所以我们就到它的右子树查找，根节点就变为7，然后我们再与根节点7对比，发现比根节点大，再到根节点7的右子树查找，根节点就变为8，找到该节点之后我们在返回。

二叉搜索树的搜索的时间复杂度：

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对于同一个元素的集合，如果元素的插入顺序不同的，则会出现不同结构的二叉搜索树，也就是说树的结构与元素插入的顺序有关。

搜索效率最优的情况下:完全二叉树，其平均比较的次数是O (logN)。

搜索效率最坏的情况:单支二叉树，其平均的比较次数是O（N) 

所以搜索二叉树的搜索的时间复杂度是O(N),时间复杂度看的是最坏的情况。

树的搜索次数与树的层次有关.

 

二叉搜索树的操作

 树的节点实现

  1. template<class T>
  2. struct TreeNode
  3. {
  4. 	TreeNode* _left;
  5. 	TreeNode* _right;
  6. 	T _key;
  7.  
  8. 	TreeNode(const T& x)
  9. 		:_key(x)
  10. 		,_left(nullptr)
  11. 		,_right(nullptr)
  12. 	{
  13.  
  14. 	}
  15. };

 搜索树的基本结构

  1. template<class T>
  2. class BinarySearchTree
  3. {
  4.  
  5. public:
  6. 	typedef  TreeNode<T> Node ;
  7. 	//需要构造函数将根节点初始化为空
  8. 	BinarySearchTree()
  9. 		:_root(nullptr)
  10. 	{
  11.  
  12. 	}
  13.     .....
  14.  
  15. private:
  16. 	//为什么是定义Node变量？
  17. 	//1.插入删除时，好判断该节点是否为空。
  18. 	//2.节点的左右孩子都是指针，方便赋值
  19.  
  20. 	Node* _root;//根节点    
  21. };

插入数据

a.树为空，则直接插入

 

b.树不为空，按二叉树搜索的性质插入的位置，插入的位置都会是叶子节点。 

 c.如果插入的数据在树中已存在，则不将数据插入到树中，并返回false。搜索树的数据都是独一无二的。

 

代码实现：

非递归版本

  1. 	bool _Insert( const T& key)
  2. 	{
  3. 		//如果树中已存在key，则返回false
  4. 		if (_root == nullptr)
  5. 		{
  6. 			_root = new Node(key);
  7. 			return true;
  8. 		}
  9. 		//遍历搜索树
  10. 		Node* cur = _root;
  11. 		Node* parent = nullptr;
  12. 		while (cur)
  13. 		{
  14. 			if (cur->_key<key)
  15. 			{
  16. 				parent = cur;
  17. 				cur = cur->_right;
  18. 			}
  19. 			else if (cur->_key > key)
  20. 			{
  21. 				parent = cur;
  22. 				cur = cur->_left;
  23. 			}
  24. 			else
  25. 			{
  26. 				return false;
  27. 			}
  28. 		}
  29.  
  30. 		//创建节点，这里用了匿名对象
  31. 		cur = new Node(key);
  32.         //判断cur节点要连接到parent的哪个节点
  33. 		if (parent->_key > key)
  34. 		{
  35. 			parent->_left = cur;
  36. 		}
  37. 		else if (parent->_key < key)
  38. 		{
  39. 			parent->_right = cur;
  40. 		}
  41. 		return true;
  42. 	}

递归的版本：

  1. 	//注意root是指针的引用
  2.  
  3.     bool _InsertR(Node* &root, const T& key)
  4. 	{
  5.         //如果节点为空，则创建节点给给它
  6. 		if (root == nullptr)
  7. 		{
  8. 			root = new Node(key);
  9. 		}
  10. 		if (root->_key > key)
  11. 		{
  12. 			_InsertR(root->_left, key);
  13. 		}
  14. 		else if(root->_key<key)
  15. 		{
  16. 			_InsertR(root->_right, key);
  17. 		}
  18. 		else {
  19. 			return false;
  20. 		}
  21. 		return true;
  22. 	}
  23.  
  24. 	bool InsertR(const T& key)
  25. 	{
  26. 		return _InsertR(_root, key);
  27. 	}

 _Insert是在private里面的，而Insert是public里的。

查找

找到了就返回该节点的地址，找不到就返回空。

  1. 	Node* find(const T& key)
  2. 	{
  3. 		if (_root == nullptr)
  4. 			return nullptr;
  5. 		Node* cur = _root;
  6. 		while (cur)
  7. 		{
  8. 			if (cur->_key > key)
  9. 			{
  10. 				cur = cur->_left;
  11. 			}
  12. 			else if (cur->_key < key)
  13. 			{
  14. 				cur = cur->_right;
  15. 			}
  16. 			else {
  17. 				return cur;
  18. 			}
  19. 		}
  20. 		return nullptr;
  21.  
  22. 	}

 

删除

   当我们要删除搜索树中某个节点的时候，删除后的树的结构也需要保持着搜索的性质，所以删除有有以下4种情况、

  • 要删除的节点无孩子节点。例如 0 4 6 9 

只要我们找到该值，直接删除掉就行。

  • 要删除的节点有左孩子的节点。例如 1

找到该值，先让该值的父亲节点区连接它的左孩子节点，然后再删除掉。父亲节点要连接该值的左孩子节点时，需要判断孩子节点是连接在父亲的左边还是右边

 

 

 

  • 要删除的节点有右孩子的节点。例如 8

找到该值，先让该值的父亲节点区连接它的右孩子节点，然后再删除掉。父亲节点要连接该值的右孩子节点时，需要判断孩子节点是连接在父亲的左边还是右边

 

  • 要删除的节点有左右孩子的节点。例如 3 5 7

如果我们直接删除这样的节点时，就会让使它的左右子树没有根节点，所以我们怎样删除这样的节点，并保持搜索二叉树的特性？

我们可以找出该值左子树最大的节点或者右子树最小的节点，去替换根节点，然后将替换的节点给删除掉。（左子树最大的节点或者右子树最小的节点去替换的根节点依旧可以保持着搜索二叉树的性质）。

删除5这个数据的过程;，找出左子树最大的值，也就是左子树最右的值，替换到根节点，然后直接将 替换的节点删除即可。

 

删除3的过程，找出左子树最大的值，也就是左子树最右的值。

代码：

  1. 	bool _erase(const T key)
  2. 	{
  3. 		if (_root == nullptr)
  4. 			return false;
  5. 		//找出key的节点
  6. 		Node* cur = _root;
  7. 		Node* parent = nullptr;
  8. 		while (cur)
  9. 		{
  10. 			if (cur->_key < key)
  11. 			{
  12. 				parent = cur;
  13. 				cur = cur->_right;
  14. 			}
  15. 			else if (cur->_key > key)
  16. 			{
  17. 				parent = cur;
  18. 				cur = cur->_left;
  19. 			}
  20. 			else {
  21. 				break;
  22. 			}
  23. 		}
  24. 		
  25. 		//第一种：删掉的是叶子节点
  26. 		//第二种：删掉只有一个孩子的节点
  27. 		//第三种：删掉的是有两个孩子的节点
  28.         //删除只有右孩子的节点
  29. 		if (cur->_left == nullptr)
  30. 		{
  31. 			if (parent==nullptr)
  32. 			{
  33. 				_root = cur->_right;
  34. 				delete cur;
  35. 				return true;
  36. 			}
  37. 			if (parent->_left == cur)
  38. 			{
  39. 				parent->_left = cur->_right;
  40. 			}
  41. 			else if (parent->_right == cur)
  42. 			{
  43. 				parent->_right = cur->_right;
  44. 			}
  45. 			delete cur;
  46. 		}
  47.         //删除只有左孩子的节点
  48. 		else if (cur->_right == nullptr)
  49. 		{
  50. 			if (parent == nullptr)
  51. 			{
  52. 				_root = cur->_left;
  53. 				delete cur;
  54. 				return true;
  55.  
  56. 			}
  57. 			if (parent->_left == cur)
  58. 			{
  59. 				parent->_left = cur->_left;
  60. 			}
  61. 			else if (parent->_right == cur)
  62. 			{
  63. 				parent->_right = cur->_left;
  64. 			}
  65. 			delete cur;
  66. 		}
  67.         //删除有左右孩子的节点
  68. 		else
  69. 		{
  70. 			//第三种情况
  71. 			Node* leftmax = cur->_left;
  72. 			Node* leftmaxparent = cur;//左子树最大节点
  73. 			//找出左子树最大的节点
  74. 			while (leftmax->_right)
  75. 			{
  76. 				leftmaxparent = leftmax;
  77. 				leftmax = leftmax->_right;
  78. 			}
  79. 			//赋给根节点
  80. 			cur->_key = leftmax->_key;
  81. 			//删除节点
  82. 			if (leftmaxparent->_left == leftmax)
  83. 			{
  84. 				leftmaxparent->_left = leftmax->_left;
  85. 			}
  86. 			else {
  87. 				leftmaxparent->_right = leftmax->_left;
  88. 			}
  89. 			delete leftmax;
  90. 			return true;
  91. 		}
  92. 		return false;
  93.  
  94. 	}

 

这段代码的含义：

 

 递归版本：

  1. 	
  2.     bool _eraseR(Node* &root,const T key)
  3. 	{
  4.         //查找key相对应的值
  5. 		if (root == nullptr)
  6. 			return false;
  7. 		if (root->_key < key)
  8. 			_eraseR(root->_right, key);
  9. 		else if (root->_key > key)
  10. 			_eraseR(root->_left, key);
  11. 		else {
  12.           
  13. 			if (root->_left == nullptr)
  14. 			{
  15. 				Node* tmp = root;
  16. 				root = root->_right;
  17. 				delete tmp;
  18. 			}
  19. 			else if (root->_right == nullptr)
  20. 			{
  21. 				Node* tmp = root;
  22. 				root = root->_left;
  23. 				delete tmp;
  24. 			}
  25. 			else
  26. 			{
  27. 				//第三种情况
  28. 				Node* leftmax = root->_left;
  29. 				Node* leftmaxparent = root;
  30. 				//找出左子树最大的节点
  31. 				while (leftmax->_right)
  32. 				{
  33. 					leftmaxparent = leftmax;
  34. 					leftmax = leftmax->_right;
  35. 				}
  36. 				//赋给根节点
  37. 				root->_key = leftmax->_key;
  38. 				//删除节点
  39. 				if (leftmaxparent->_left == leftmax)
  40. 				{
  41. 					leftmaxparent->_left = leftmax->_left;
  42. 				}
  43. 				else {
  44. 					leftmaxparent->_right = leftmax->_left;
  45. 				}
  46. 				delete leftmax;
  47. 				return true;
  48. 			}
  49. 		}
  50. 		return false;
  51.  
  52. 	}
  53.  
  54. 	bool eraseR(const T& x)
  55. 	{
  56. 		return _eraseR(_root, x);
  57. 	}

_eraseR是private里面的，eraseR是public里面的。 

 

 

eraseR是对_eraseR的封装，方便被调用。

拷贝构造函数

  1.  
  2. 	Node* _copy(Node* root)
  3. 	{
  4. 		if (root == nullptr)
  5. 			return nullptr;
  6. 		Node* copyroot = new Node(root->_key);
  7. 		copyroot->_left=_copy(root->_left);
  8. 		copyroot->_right=_copy(root->_right);
  9. 		return copyroot;	
  10. 	}
  11.  
  12. 	BinarySearchTree(BinarySearchTree<T>& t)
  13. 	{
  14. 		_root=_copy(t._root);
  15. 	}

 赋值重载函数

 

 析构函数：

  1. 	void Destory(Node* root)
  2. 	{
  3. 		if (root == nullptr)
  4. 			return;
  5. 		Destory(root->_left);
  6. 		Destory(root->_right);
  7. 		delete root;
  8.  
  9. 	}
  10.  
  11. 	~BinarySearchTree()
  12. 	{
  13. 		Destory(_root);
  14. 		_root = nullptr;
  15. 	}

2.4 二叉搜索树的应用

1.K模型：K模型只有key作为关键码，也就是定义树的节点只需要存_key一个即可，关键码即为搜索到的值。如上我们写的搜索树就是k模型，因为树的节点就只有一个key可以存储数据。

 

比如：我们要进学校的图书馆就需要刷我们的学生卡，通过磁感应将门打开。如下：

 此时我们就需要先将学生的学号录入到该门的管理系统，然后将数据建立起搜索树，我们的学号在学校是唯一的，当我们刷卡的时候，就会去管理系统快速查找我们的学号，找到了门就开了。

k模型在实际应用中就是就是查找在不在的问题。

2.kv模型:每一个关键码key都有一个对应的value值，也就是说树的节点中有两个值，一个是key，一个是value的值，我们通过key找到对应的节点，然后将相对应的value给映射出来。也就是说，我们增删查改的时候也是按key进行插入或者删除。只是创建节点，增加了一个value值。

 场景1：我们去网上买高铁票，每张高铁票的信息都有与一个身份证号绑定在一起的，当我们进高铁站都需要刷身份证在搜索树中查找有没有你的身份证号，找到了，通过身份证号映射你的高铁信息，看看有没有你的班次，门才是否可以被开。在这里_key是身份证，它是独一无二的，_value是高铁信息，通过身份证将它给映射出来。

 场景2：

英汉词典就是英文与中文的对应关系，我们只需要查找有没有该英文，找到了，就通过映射关系，将该英文的单词的中文给映射出来。

用kv模型的搜索树写一个简单的词典：

  1. int main()
  2. {
  3. 	BinarySearchTree<string ,string> v;
  4. 	v._Insert("string","字符串");
  5. 	v._Insert("apple","苹果");
  6. 	v._Insert("automate", "n.自动化，v.使自动化");
  7. 	v._Insert("voluntary", "adj.自愿的主动的，n.志愿者");
  8. 	string s;
  9. 	while (cin>>s)
  10. 	{
  11. 		struct TreeNode<string,string>* ret = v.find(s);
  12. 		if (ret == nullptr)
  13. 		{
  14. 			cout << "没有找到该单词" << endl;
  15. 		}
  16. 		else
  17. 		{
  18.  
  19. 			cout <<endl << "	中文:" << ret->_value << endl;
  20. 		}
  21. 	}
  22. 	return 0;
  23. }

运行结果： 

 

场景3：

统计水果次数。

如下

  1. int main()
  2. {
  3. 	const string str[] = { "苹果","西瓜","芒果","苹果","西瓜","西瓜","西瓜","苹果","芒果" };
  4. 	BinarySearchTree<const string, int> count;
  5. 	for (auto s : str)
  6. 	{
  7. 		auto ret = count.find(s);
  8. 		if (ret == nullptr)
  9. 		{
  10. 			count._Insert(s, 1);
  11. 		}
  12. 		else {
  13. 			ret->_value++;
  14. 		}
  15. 	}
  16. 	count.Inorder();
  17.  
  18. 	return 0;
  19. }

输出结果：

其中Inorder是将树中所有的节点都给打印出来，代码如下：

  1. 	void _Inorder(Node* root)
  2. 	{
  3. 		if (root == nullptr)
  4. 			return;
  5.  
  6. 		_Inorder(root->_left);
  7. 		cout << root->_key << ":" << root->_value << endl;
  8. 		_Inorder(root->_right);
  9. 	}
  10.  
  11. 	void Inorder()
  12. 	{
  13. 		_Inorder(_root);
  14. 	}

 _Inorder是private里面的，而Inorder是public里面的。

好了，今天分享的知识就到这里了，喜欢的小伙伴们，麻烦帮我点个三连，谢谢你们了。

推荐阅读

java 8 lambda 排序_Java8：Lambda表达式增强版Comparator和排序

1、概述在这篇教程里，我们将要去了解下即将到来的JDK 8(译注，现在JDK 8已经发布了)中的Lambda表达式——特别是怎样使用它来编写Comparator和对集合(Collection)进行排序。首先，让我们先定义一个简单的实体类：public class Human {private String name;private int age;public Human() {super();}...

Nginx安装部署与配置管理_Ra_sh的博客

一、HTTP 介绍HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 音视频文件等）。1、HTTP 工作原理HTTP协议工作于客户端-服务端架构上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。可以实现 Web服务器 软件有：一般部署在 Lin

django模板语言中如何默认将None值显示为空字符串_专职的博客

1. 只需要使用一个模板过滤器即可：default_if_none{{ data.customer_id|default_if_none:"" }}

keil中文编码编译错误问题(direction is incompatible)

环境：keil编译，sourceinsight编辑项目添加宏定义转换中文字符函数之后，一直报错定义不兼容：error：direction is incompatible1.使用未定义函数（或者是声明顺序）很多时候这种错误，大家一般都能排查出来2.单纯的编码错误（1.）将sourceinsight编辑的该文件改成UTF-8 BOM形式（2.）添加keil相关的控制项option for Target --》 c++ --》Misc Control添加：-..

英文邮件礼仪：向教授请教学术问题_weixin

英文邮件礼仪：向教授请教学术问题 邮件主题 邮件主题（subject）不需要写自己的名字。名字是在邮件系统设置里设定好的，在发件时会替换显示实际地址，所以无需在主题里再写一遍。[关键内容是要在主题里就写明白是否有推荐人，以及主要是什么事。很多教授只看主题。] 一个好的标题，要能简洁地概括邮件的目的或内容。如果你对教授的某个研究项目感兴趣，就可以用这个研究方向作标题，例如&quot;D...