c++之二叉树【进阶版】

r囧r小猫 2024-03-26 12:19 96阅读 0赞

#### 前言 ####

在c语言阶段的数据结构系列中已经学习过二叉树，但是这篇文章是二叉树的进阶版，因为首先就会讲到一种树形结构“二叉搜索树”，学习二叉搜索树的目标是为了更好的理解map和set的特性。二叉搜索树的特性就是左子树键值小于根，右子树键值大于根，所以二叉搜索树就天然的具有查找功能，有时二叉搜索树又叫二叉排序树或者二叉查找树。

**目录**

前言

Ⅰ、二叉搜索树概念

Ⅱ、二叉搜索树操作

Ⅲ、二叉搜索树的实现

Ⅳ、 二叉搜索树的应用

Ⅴ、二叉搜索树的性能分析

Ⅵ、二叉树进阶面试题

--------------------

#### Ⅰ、二叉搜索树概念 ####

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

*●若它的左子树不为空，则左子树上所有节点的值都小于根节点的值*

*●若它的右子树不为空，则右子树上所有节点的值都大于根节点的值*

*●它的左右子树也分别为二叉搜索树*

*●它没有重复的键值*

![070c08046d0b41b9ba986f66d144a6ea.png][]

#### Ⅱ、二叉搜索树操作 ####

![c5b2f8a3166b4a6f91d87bfadd717db2.png][]

> int a\[ \] = \{8, 3, 1, 10, 6, 4, 7, 14, 13\};

**1. 二叉搜索树的查找**

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

b、最多查找高度次，走到到空，还没找到，这个值不存在。

![222ae1a7cf81441498dae43c267d0ad5.gif][]

**2. 二叉搜索树的插入**

插入的具体过程如下：

a. 树为空，则直接新增节点，赋值给root指针

b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

![58e260969de04768a4f7ebeba26b8dc2.png][]

**1. 二叉搜索树的删除**

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情 况：

a. 要删除的结点无孩子结点

b. 要删除的结点只有左孩子结点

c. 要删除的结点只有右孩子结点

d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程 如下：

●情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除

●情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除

●情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点 中，再来处理该结点的删除问题--替换法删除

如图理解，情况a实质就是删除1,4,7,13可以直接删除。

![6474a79e9f4d4c8e9edb01da860e54ae.png][]

关于情况b，情况c，就需要详细探讨

![3c02248bdf32415ebade6d9af5bf6a72.png][]

对于情况d是最难以理解的，这种情况就好比删除3和8，他们是需要替换法删除的场景，这种情况就需要找子树右边的最小值(minright)，找到之后minright的key值与cur的key交换(赋值)后再判断后进行链接。

![0364ea7a5ebc403e804692d6c667942e.png][]

但是通下面代码我们发现，这段代码删除8时就会发现root为nullptr，这样就出现错误了，还有一个问题就是minright可以是parent左右子树，所以关于删除的时候还需要判断是否parent的左右子树

![6b2bd6d6656c445eaff428d880417c0b.png][]

![d8fe2fba26294d92a4bfd983937fc8bc.png][]

#### Ⅲ、二叉搜索树的实现 ####

二叉搜索树代码的实现，查找，插入是比较容易理解的，对于删除考虑的情况比较多。主要分三种情况，1.直接删除，2.左右子树为nullptr，交换删除，3.左右子树都不为nullptr，需要找minright替换key值后链接。

对于整个结构与我之前学习的二叉树基本一样，只是用到了c++，封装了节点（该节点中有左右节点和key值），通过模板实现不同参数的调用。

**非递递归代码实现如下**

#pragma once
    #include <iostream>
    #include <string>
    using namespace std;
    
    namespace K
    {
    	template<class K>
    	struct BSTreeNode
    	{
    		BSTreeNode<K>* _left;
    		BSTreeNode<K>* _right;
    		K _key;
    
    		BSTreeNode(const K& key)
    			:_key(key)
    			, _left(nullptr)
    			, _right(nullptr)
    		{}
    	};
    	template<class K>
    	class BSTree
    	{
    		typedef BSTreeNode<K> Node;
    	public:
    
    		BSTree()
    			:_root(nullptr)
    		{}
    
    		BSTree(const BSTree<K> &t)
    		{
    			_root = Copy(t._root);
    		}
    
    		BSTree<K>& operator=(BSTree<K> t)
    		{
    			swap(_root, t._root);
    			return *this;
    		}
    
    		~BSTree()
    		{
    			Destroy(_root);
    			_root=nullptr;
    		}
    		
    		bool Insert(const K& key)
    		{
    			if (_root == nullptr)
    			{
    				_root = new Node(key);
    				return true;
    			}
    
    			Node* parent = nullptr;
    			Node* cur = _root;
    			while (cur)
    			{
    				if (cur->_key < key)
    				{
    					parent = cur;
    					cur = cur->_right;
    				}
    				else if (cur->_key > key)
    				{
    					parent = cur;
    					cur = cur->_left;
    				}
    				else
    				{
    					return false;
    				}
    			}
    
    			cur = new Node(key);
    			if (parent->_key < key)
    			{
    				parent->_right = cur;
    			}
    			else
    			{
    				parent->_left = cur;
    			}
    
    			return true;
    		}
    
    		bool Erase(const K& key)
    		{
    			Node* parent = nullptr;
    			Node* cur = _root;
    			while (cur)
    			{
    				if (cur->_key < key)
    				{
    					parent = cur;
    					cur = cur->_right;
    				}
    				else if (cur->_key > key)
    				{
    					parent = cur;
    					cur = cur->_left;
    				}
    				else
    				{
    					// 1、左为空
    					// 2、右为空
    					// 3、左右都不为空，替换删除
    					if (cur->_left == nullptr)
    					{
    						//if (parent == nullptr)
    						if (cur == _root)
    						{
    							_root = cur->_right;
    						}
    						else
    						{
    							if (parent->_left == cur)
    							{
    								parent->_left = cur->_right;
    							}
    							else
    							{
    								parent->_right = cur->_right;
    							}
    						}
    
    						delete cur;
    					}
    					else if (cur->_right == nullptr)
    					{
    						//if (parent == nullptr)
    						if (cur == _root)
    						{
    							_root = cur->_left;
    						}
    						else
    						{
    							if (parent->_left == cur)
    							{
    								parent->_left = cur->_left;
    							}
    							else
    							{
    								parent->_right = cur->_left;
    							}
    						}
    
    						delete cur;
    					}
    					else
    					{
    						// 右子树的最小节点
    						Node* parent = cur;
    						Node* minRight = cur->_right;
    						while (minRight->_left)
    						{
    							parent = minRight;
    							minRight = minRight->_left;
    						}
    
    						cur->_key = minRight->_key;
    
    						if (minRight == parent->_left)
    						{
    							parent->_left = minRight->_right;
    						}
    						else
    						{
    							parent->_right = minRight->_right;
    						}
    						delete minRight;
    					}
    
    					return true;
    				}
    			}
    
    			return false;
    		}
    
    		void InOrder()
    		{
    			_InOrder(_root);
    			cout << endl;
    		}
    
    
    	private:
    		
    		void Destroy(Node* root)
    		{
    			if (root == nullptr)
    				return;
    
    			Destroy(root->_left);
    			Destroy(root->_right);
    			delete root;
    		}
    
    		Node*  Copy(Node *root)
    		{
    			if (root == nullptr)
    				return nullptr;
    			
    			Node* newRoot = new Node(root->_key);
    			newRoot->_left = Copy(root->_left);
    			newRoot->_right = Copy(root->_right);
    
    			return newRoot;
    		}
    
    	
    		bool Find(const K& key)
    		{
    			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;
    		}
    
    		void _InOrder(Node* root)
    		{
    			if (root == nullptr)
    				return;
    
    			_InOrder(root->_left);
    			cout << root->_key << " ";
    			_InOrder(root->_right);
    		}
    	private:
    		Node* _root = nullptr;
    	};
    }

**递归**

这里递归主要讲解删除（Erase），相信大家之前对递归也是有所涉猎的。对于Erase的实现，开始也是通过递归查找key节点，还需要循环找到minright，然后通过(swap)交换key值和minright值，之后再通过递归（cur的子树）删除。下面我们就来深入分析递归删除，列如删除如图3。

![0a70c9bddc1e45e28d8880443bbdd1d6.png][]

●1.先通过递归查找到删除节点

![de384e954c2a4e768a14f8dc9b5c77b4.png][]

●2.如果是左右子树为nullptr，直接链接到根（root）

![e0bdded0d9234cb7a76263222cc3d16f.png][]

●3.这里如果删除的是3，就是通过上面步骤找到3为cur，然后判断出cur的左右子树都不为nullptr，这时就需要寻找minright，找到minright之后，swap交换（3,4），然后递归删除4节点的右子树的3。

![11d941b3bb9d47449ec8d4a41d7d8efb.png][]

![791ea04b55be4c0b961bf7e7f98d2a97.png][]

*最后需要注意的一点是，递归就会调用\_root，所以我们可以在类中先封装再调用。*

非递归代码实现如下

namespace K
    {
    	template<class K>
    	struct BSTreeNode
    	{
    		BSTreeNode<K>* _left;
    		BSTreeNode<K>* _right;
    		K _key;
    
    		BSTreeNode(const K& key)
    			:_key(key)
    			, _left(nullptr)
    			, _right(nullptr)
    		{}
    	};
    
    	template<class K>
    	class BSTree
    	{
    		typedef BSTreeNode<K> Node;
    	public:
    
    		BSTree()
    			:_root(nullptr)
    		{}
    
    		BSTree(const BSTree<K> &t)
    		{
    			_root = Copy(t._root);
    		}
    
    		BSTree<K>& operator=(BSTree<K> t)
    		{
    			swap(_root, t._root);
    			return *this;
    		}
    
    		~BSTree()
    		{
    			Destroy(_root);
    			_root=nullptr;
    		}
    		void InOrder()
    		{
    			_InOrder(_root);
    			cout << endl;
    		}
    
    		bool InsertR(const K& key)
    		{
    			return _InsertR(_root,key);
    		}
    
    		bool FindR(const K& key)
    		{
    			return _FindR(_root, key);
    		}
    
    		bool EraseR(const K& key)
    		{
    			return _EraseR(_root, key);
    		}
    
    	private:
    		
    		void Destroy(Node* root)
    		{
    			if (root == nullptr)
    				return;
    
    			Destroy(root->_left);
    			Destroy(root->_right);
    			delete root;
    		}
    		Node*  Copy(Node *root)
    		{
    			if (root == nullptr)
    				return nullptr;
    			
    			Node* newRoot = new Node(root->_key);
    			newRoot->_left = Copy(root->_left);
    			newRoot->_right = Copy(root->_right);
    
    			return newRoot;
    		}
    		bool _EraseR(Node*& root, const K& key)
    		{
    			if (root == nullptr)
    			{
    				return false;
    			}
    
    			if (root->_key < key)
    			{
    				return _EraseR(root->_right, key);
    			}
    			else if (root->_key > key)
    			{
    				return _EraseR(root->_left, key);
    			}
    			else
    			{
    				Node* del = root;
    				if (root->_right == nullptr)
    				{
    					root = root->_left;
    				}
    				else if (root->_left == nullptr)
    				{
    					root = root->_right;
    				}
    				else
    				{
    					Node* minRight = root->_right;
    					while (minRight->_left)
    					{
    						minRight = minRight->_left;
    					}
    
    					swap(root->_key, minRight->_key);
    
    					// 转换后在子树中去删除节点
    					return _EraseR(root->_right, key);
    				}
    				delete del;
    				return true;
    			}
    		}
    
    		bool _InsertR(Node*& root, const K& key)
    		{
    			if (root == nullptr)
    			{
    				root = new Node(key);
    				return true;
    			}
    
    			if (root->_key < key)
    				return  _InsertR(root->_right, key);
    			else if (root->_key > key)
    				return  _InsertR(root->_left, key);
    			else
    				return false;
    		}
    		bool _FindR(Node* root, const K& key)
    		{
    			if (root == nullptr)
    			{
    				return false;
    			}
    			if (root->_key < key)
    			{
    				return  _FindR(root->_right);
    			}
    			else if (root->_key> key)
    			{
    				return _FindR(root->_left);
    			}
    			else
    			{
    				return true;
    			}
    		}
    private:
    		Node* _root = nullptr;
    	};
    }

#### Ⅳ、 二叉搜索树的应用 ####

1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。 比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

○以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树

○在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2. KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见：

○比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；

○再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是就构成一种键值对。

改造二叉搜索树为KV结构如下

namespace KV
    {
    	template<class K, class V>
    	struct BSTreeNode
    	{
    		BSTreeNode<K, V>* _left;
    		BSTreeNode<K, V>* _right;
    		K _key;
    		V _value;
    
    		BSTreeNode(const K& key, const V& value)
    			:_key(key)
    			, _value(value)
    			, _left(nullptr)
    			, _right(nullptr)
    		{}
    	};
    
    	template<class K, class V>
    	class BSTree
    	{
    		typedef BSTreeNode<K, V> Node;
    	public:
    		bool Insert(const K& key, const V& value)
    		{
    			if (_root == nullptr)
    			{
    				_root = new Node(key, value);
    				return true;
    			}
    
    			Node* parent = nullptr;
    			Node* cur = _root;
    			while (cur)
    			{
    				if (cur->_key < key)
    				{
    					parent = cur;
    					cur = cur->_right;
    				}
    				else if (cur->_key > key)
    				{
    					parent = cur;
    					cur = cur->_left;
    				}
    				else
    				{
    					return false;
    				}
    			}
    
    			cur = new Node(key, value);
    			if (parent->_key < key)
    			{
    				parent->_right = cur;
    			}
    			else
    			{
    				parent->_left = cur;
    			}
    
    			return true;
    		}
    
    		Node* Find(const K& key)
    		{
    			Node* cur = _root;
    			while (cur)
    			{
    				if (cur->_key < key)
    				{
    					cur = cur->_right;
    				}
    				else if (cur->_key > key)
    				{
    					cur = cur->_left;
    				}
    				else
    				{
    					return cur;
    				}
    			}
    
    			return nullptr;
    		}
    
    		void Inorder()
    		{
    			_Inorder(_root);
    		}
    
    		void _Inorder(Node* root)
    		{
    			if (root == nullptr)
    				return;
    
    			_Inorder(root->_left);
    			cout << root->_key << ":" << root->_value << endl;
    			_Inorder(root->_right);
    		}
    	private:
    		Node* _root = nullptr;
    	};
    }

**测试1：**通过英文查找中文，这个时候就用到KV搜索树，我们可以给树的key和value定义都为string类型，然后将信息插入到KV搜索树。最后通过查找key值，如果有就打印value即可。

void TestBSTree2()
    {
    	//词库中单词都放进这个搜索树中
    	//key的搜索模型，判断在不在？
    	//场景：检查单词拼写是否正确/车库出入系统/...
    
    	//K::BSTree<string> dict;
    	//Key/Value的搜索模型，通过Key查或者修改Value
    
    	KV::BSTree<string, string> dict;
    	dict.Insert("sort", "排序");
    	dict.Insert("string", "字符串");
    	dict.Insert("left", "左边");
    	dict.Insert("right", "右边");
    	
    	string str;
    	while(cin >> str)
    	{
    		KV::BSTreeNode<string, string>* ret = dict.Find(str); 
    		if (ret)
    		{
    			cout << ret->_value << endl;
    		}
    		else
    		{
    			cout << "没有这个单词" << endl;
    		}
    	}
    
    }

> 编译结果：sort 排序 left 左边 right 右边 hello 没有这个单词

**测试2：**统计水果出现的次数

void TestBSTree3()
    {
    
    	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
    		"苹果", "香蕉", "苹果", "香蕉" };
    	KV::BSTree<string, int> countTree;
    	for (auto e : arr)
    	{
    		auto* ret = countTree.Find(e);
    		if (ret == nullptr)
    		{
    			countTree.Insert(e, 1);
    		}
    		else
    		{
    			ret->_value++;
    		}
    	}
    	countTree.Inorder();
    }

#### **Ⅴ、**二叉搜索树的性能分析 ####

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。 对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二 叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

![e8e0fc39320247aaaf2471dbbd662320.png][]

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：$log\_2 N$

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：$\\frac\{N\}\{2\}$

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插 入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。

#### Ⅵ、二叉树进阶面试题 ####

这些题目更适合使用C++完成，难度也更大一些

1. 二叉树创建字符串。[OJ链接][OJ]

2. 二叉树的分层遍历1。[OJ链接][OJ 1]

3. 二叉树的分层遍历2。[OJ链接][OJ 2]

4. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。[OJ链接][OJ 3]

5. 二叉树搜索树转换成排序双向链表。[OJ链接][OJ 4]

6. 根据一棵树的前序遍历与中序遍历构造二叉树。 [OJ链接][OJ 5]

7. 根据一棵树的中序遍历与后序遍历构造二叉树。[OJ链接][OJ 6]

8. 二叉树的前序遍历，非递归迭代实现 。[OJ链接][OJ 7]

9. 二叉树中序遍历 ，非递归迭代实现。[OJ链接][OJ 8]

10. 二叉树的后序遍历 ，非递归迭代实现。[OJ链接][OJ 9]

[070c08046d0b41b9ba986f66d144a6ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/86293696adb4485d82bad65f3e28028f.png
[c5b2f8a3166b4a6f91d87bfadd717db2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5ab51e366d0e4882b9eb229b3ad7cc1c.png
[222ae1a7cf81441498dae43c267d0ad5.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a71736dc00db4077a87c05263c28392c.png
[58e260969de04768a4f7ebeba26b8dc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/7ba0588edfb34f8698b9d584417f5678.png
[6474a79e9f4d4c8e9edb01da860e54ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c684c49ff73a44d4b483770ef39ee42d.png
[3c02248bdf32415ebade6d9af5bf6a72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c90925187a77463180576d65c6c73060.png
[0364ea7a5ebc403e804692d6c667942e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/aaf99d209531444b9f4ffe60b04eb38a.png
[6b2bd6d6656c445eaff428d880417c0b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/99bfddb58d5349bc9327d151597561e9.png
[d8fe2fba26294d92a4bfd983937fc8bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a31c0fc218a24f73a92c92d3620ff9fc.png
[0a70c9bddc1e45e28d8880443bbdd1d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a4ba00ee01394fb9ae563ed3c3f6ce67.png
[de384e954c2a4e768a14f8dc9b5c77b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/464a086aadc24e53bbcf160811745cee.png
[e0bdded0d9234cb7a76263222cc3d16f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/eddd334dcf504f909209b41ace0be782.png
[11d941b3bb9d47449ec8d4a41d7d8efb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/e40fa3e26d5746458d434633699114c2.png
[791ea04b55be4c0b961bf7e7f98d2a97.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/d6e9615ebe5e4bf6922039cf59ba520c.png
[e8e0fc39320247aaaf2471dbbd662320.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5e344a913c8c40eb88906c9a2095fe17.png
[OJ]: https://leetcode.cn/problems/construct-string-from-binary-tree/
[OJ 1]: https://leetcode.cn/problems/binary-tree-level-order-traversal/
[OJ 2]: https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/
[OJ 3]: https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/
[OJ 4]: https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId=13&&tqId=11179&rp=1&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking
[OJ 5]: https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
[OJ 6]: https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
[OJ 7]: https://leetcode.cn/problems/binary-tree-preorder-traversal/
[OJ 8]: https://leetcode.cn/problems/binary-tree-inorder-traversal/
[OJ 9]: https://leetcode.cn/problems/binary-tree-postorder-traversal/