二叉搜索树：数据世界的“快速寻路指南”

一、二叉搜索树

1. 二叉搜索树的概念

什么是二叉搜索树呢？

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

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

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

. 它的左右子树也分别为二叉搜索树。

. 二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景，后续学到的map/set/multimap/multiset系列容器底层就是二叉搜索树，其中map/set不支持插入相等的值，multimap/multiset支持插入相等的值。

而之所以二叉搜索树又叫二叉排序树 ，是因为二叉搜索树的中序遍历刚好是有序的。

这就是一棵二叉排序树，根节点开始就是一棵二叉搜索树，根节点的左右子树也分别是一棵二叉搜索树。当然了，二叉搜索树并不一定就是一棵满二叉树。

2. 二叉搜索树的性能分析

主要从增删改查等方面来评估二叉搜索树的性能 。二叉搜索树从技术上是允许修改数据的，但是原则上来讲强烈不建议，甚至禁止。

因为二叉搜索树的核心在于搜索，它的排序不变性 ，对于任何节点，其左子树的值都小于等于它，右子树的值都大于等于它。如果贸然修改了某个节点的值，很可能就破坏了二叉搜索树的排序不变性。

所以，正确的"修改"操作是删除某个节点，在插入一个新的节点。

如果二叉搜索树是一棵完全二叉树或者接近完全二叉树，那么这棵树的高度是logN ，增删改查的效率就是这棵树的高度次（logN），无论是哪种操作，只需要通过比较当前节点的值与插入或者删除或者查找的值进行比较即可，小于当前节点的值向左走，大于向右走。

这是理想的情况下，二叉搜索树的效率还是很不错的。但有一种情况，会使二叉搜索树的效率很低。

像这种情况，二叉搜索树退化成了单支树，它的高度为N，它的效率就会大幅下降，是无法满足需求的。所以，后续针对二叉搜索树的缺点，有了平衡二叉搜索树（AVL树）和红黑树。

另外需要说明的是，二分查找也可以实现O(logN)级别的查找效率，但是二分查找有两个缺点：

1.需要存储在支持下标随机访问的结构中，并且有序。

2.插入和删除的效率很低，因为存储在下标随机访问的结构中，插入和删除数据一般需要挪动数据，时间复杂度为O(N)。

3. 二叉搜索树的插入

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

2.树不为空，按照二叉搜索树的性质，插入值比当前节点大往右走，比当前节点小往左走，找到空位置，插入新节点。

3.如果支持插入相等的值，插入值跟当前节点相等的值可以往右走，也可以往左走，找到空位置，插入新节点。（注意保持逻辑的一致性，插入相等的值不要一会往右走，一会往左走）

4. 二叉搜索树的查找

1.从根开始比较，查找x，x比根的值大则往右边走查找，x比根值小则往左边走查找。

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

3.如果不支持插入相等的值，找到x即可返回。

4.如果支持插入相等的值，意味着有多个x存在，一般要求查找中序的第一个x。

5. 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在则返回false。

如果查找元素存在则分以下四种情况分别处理（假设要删除的节点为N）：

1.要删除的N节点左右孩子均为空。

处理方法 ：将N节点的父亲对应的孩子指针置为空，直接删除N节点。

2.要删除的N节点左孩子为空，右孩子不为空。

处理方法 ：把N节点的父亲对应的孩子指针指向N的右孩子，直接删除N节点。

3.要删除的N节点右孩子为空，左孩子不为空。

处理方法 ：把N节点的父亲对应的孩子指针指向N的左孩子，直接删除N节点。

4.要删除的N节点左右孩子均不为空。

处理方法 ：无法直接删除N节点，因为N的两个孩子无处安放，只能用替换法删除 。找N节点左子树的最大节点R（最右节点）或者右子树的最小节点R（最左节点）替代N。因为只有这样才能符合二叉搜索树的规则。替代只需要交换两个节点的值即可，这样要删除的节点就转变成了上述情况2或者3，可以直接删除。

6. 二叉搜索树的代码详解

6.1 二叉搜索树节点的定义

template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* _left;
	BSTNode<K>* _right;

	//构造
	BSTNode(const K& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{
	}
};

6.2 二叉搜索树的定义

template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
private:
	Node* root = nullptr;
};

6.3 insert

bool Insert(const K& key)
{
	if (root == nullptr)
	{
		root = new Node(key);
		return true;
	}
	//根节点不为空
	Node* parent = nullptr, * 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;
}

二叉搜索树为空，直接申请节点，插入，让root指向该节点。否则，不为空，按照二叉搜索树的规则去查找，插入值已经存在就返回false，否则找到空位置，申请节点插入。

6.4 find

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;
}

查找值比当前节点值大，往右子树查找，比当前节点值小，往左子树查找，相等返回true，否则，找不到。

6.5 erase

bool Erase(const K& key)
{
	Node* parent = nullptr, * cur = root;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			//开始删除
			if (cur->_left == nullptr)
			{
				if (cur == root)
				{
					root = cur->_right;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				if (cur == root)
				{
					root = cur->_left;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			else
			{
				//找右子树最小节点（最左节点）
				Node* replaceparent = cur, * replace = cur->_right;
				while (replace->_left)
				{
					replaceparent = replace;
					replace = replace->_left;
				}
				swap(cur->_key, replace->_key);
				if (replaceparent->_left == replace)
				{
					replaceparent->_left = replace->_right;
				}
				else
				{
					replaceparent->_right = replace->_right;
				}
				delete replace;
			}
			return true;
		}
	}
	return false;
}

按照二叉搜索树的规则去查找，找到了就开始删除，分情况讨论，反之未找到，返回false。

7. 二叉搜索树完整代码

. SearchBinaryTree.h

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


template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* _left;
	BSTNode<K>* _right;

	//构造
	BSTNode(const K& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{
	}
};


template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	bool Insert(const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		//根节点不为空
		Node* parent = nullptr, * 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;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	void InOrder()
	{
		_InOrder(root);
		cout << endl;
	}

	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;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr, * cur = root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//开始删除
				if (cur->_left == nullptr)
				{
					if (cur == root)
					{
						root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == root)
					{
						root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					//找右子树最小节点（最左节点）
					Node* replaceparent = cur, * replace = cur->_right;
					while (replace->_left)
					{
						replaceparent = replace;
						replace = replace->_left;
					}
					swap(cur->_key, replace->_key);
					if (replaceparent->_left == replace)
					{
						replaceparent->_left = replace->_right;
					}
					else
					{
						replaceparent->_right = replace->_right;
					}
					delete replace;
				}
				return true;
			}
		}
		return false;
	}
private:
	Node* root = nullptr;
};

. test.cc

#define _CRT_SECURE_NO_WARNINGS



#include"SearchBinaryTree.h"

int main()
{
	int a[] = { 8, 3, 1, 10, 1, 6, 4, 7, 14, 13 };
	BSTree<int> t;
	for (const auto& e : a)
	{
		t.Insert(e);
	}
	t.Insert(16);
	t.InOrder();

	cout << t.Find(20) << endl;
	cout << t.Find(8) << endl;


	t.Erase(8);
	t.InOrder();

	t.Erase(3);
	t.InOrder();

	t.Erase(6);
	t.InOrder();

	t.Erase(13);
	t.InOrder();

	for (auto& e : a)
	{
		t.Erase(e);
		t.InOrder();
	}
	return 0;
}

8. 二叉搜索树key和key/value使用场景

. key搜索场景

只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，搜索场景只需要判断key在不在。

场景一：小区无人值守车库，小区车库买了车位的业主，车才能进入小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌号在不在系统中，在就抬杆，不在就无法进入。

场景二：检查一篇英文文章单词是否正确，将词库中的所有单词放入二叉搜索树中，读取文章中的单词，查找是否在二叉搜索树中。

. key/value的使用场景

每一个关键码key，都有一个对应的值value，value可以是任意类型的对象，树的结构中除了需要存储key还要存储对应的value。

增、删、查还是以key为关键字按照二叉搜索树的规则进行比较，可以快速查找到key对应的value。

key/value的二叉搜索树支持修改，但依然不允许修改key，但可以修改value。

场景一：英汉互译，树的结构中存储key(英文)和value(中文)，搜索时输入英文，同时返回中文。

场景二：商场无人值守车库，入口进场时扫描车牌，记录车牌和入场时间，出口离场时，扫描车牌，查找入场时间，用当前时间-入场时间就可以得到停车时长，计算停车费用。

8.1 拷贝构造

BSTree(const BSTree<K, V>& t)
{
	root = Copy(t.root);
}
Node* Copy(Node* root)
{
	if (root == nullptr)
	{
		return nullptr;
	}
	Node* newnode = new Node(root->_key, root->_value);
	newnode->_left = Copy(root->_left);
	newnode->_right = Copy(root->_right);
	return newnode;
}

递归式的申请节点，实现拷贝构造。

8.2 operator=

BSTree<K, V>& operator=(BSTree<K, V> t)
{
	swap(root, t.root);
	return *this;
}

拷贝构造+交换实现。

8.3 析构函数

~BSTree()
{
	Destroy(root);
	root = nullptr;
}
void Destroy(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

递归式的删除节点，先遍历左子树再遍历右子树，左右孩子都为空就开始删除（叶子结点）。

8. key/value的完整代码

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

namespace key_value
{
	template<class K, class V>
	struct BSTNode
	{
		K _key;
		V _value;
		BSTNode<K, V>* _left;
		BSTNode<K, V>* _right;

		//构造
		BSTNode(const K& key, const V& value)
			:_key(key)
			, _value(value)
			, _left(nullptr)
			, _right(nullptr)
		{
		}
	};


	template<class K, class V>
	class BSTree
	{
		typedef BSTNode<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, * 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;
		}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
		void InOrder()
		{
			_InOrder(root);
			cout << endl;
		}

		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;
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr, * cur = root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//开始删除
					if (cur->_left == nullptr)
					{
						if (cur == root)
						{
							root = cur->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else if (cur->_right == nullptr)
					{
						if (cur == root)
						{
							root = cur->_left;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					else
					{
						//找右子树最小节点（最左节点）
						Node* replaceparent = cur, * replace = cur->_right;
						while (replace->_left)
						{
							replaceparent = replace;
							replace = replace->_left;
						}
						swap(cur->_key, replace->_key);
						swap(cur->_value, replace->_value);
						if (replaceparent->_left == replace)
						{
							replaceparent->_left = replace->_right;
						}
						else
						{
							replaceparent->_right = replace->_right;
						}
						delete replace;
					}
					return true;
				}
			}
			return false;
		}
		BSTree()
			:root(nullptr)
		{
		}

		~BSTree()
		{
			Destroy(root);
			root = nullptr;
		}
		BSTree(const BSTree<K, V>& t)
		{
			root = Copy(t.root);
		}
		BSTree<K, V>& operator=(BSTree<K, V> t)
		{
			swap(root, t.root);
			return *this;
		}
	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* newnode = new Node(root->_key, root->_value);
			newnode->_left = Copy(root->_left);
			newnode->_right = Copy(root->_right);
			return newnode;
		}
		Node* root = nullptr;
	};
}

#define _CRT_SECURE_NO_WARNINGS

#include"SearchBinaryTree.h"

int main()
{
	/*int a[] = { 8, 3, 1, 10, 1, 6, 4, 7, 14, 13 };
	key_value::BSTree<int, int> t;
	for (const auto& e : a)
	{
		t.Insert(e, 1);
	}
	t.Insert(16, 1);
	t.InOrder();

	cout << t.Find(20) << endl;
	cout << t.Find(8) << endl;


	t.Erase(8);
	t.InOrder();

	t.Erase(3);
	t.InOrder();

	t.Erase(6);
	t.InOrder();

	t.Erase(13);
	t.InOrder();

	for (auto& e : a)
	{
		t.Erase(e);
		t.InOrder();
	}*/


	/*key_value::BSTree<string, string> dict;
	dict.Insert("left", "左边");
	dict.Insert("right", "右边");
	dict.Insert("insert", "插入");
	dict.Insert("string", "字符串");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << "->" << ret->_value << endl;
		}
		else
		{
			cout << "无此单词，请重新输入" << endl;
		}
	}*/


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

	countTree.InOrder();
	return 0;
}