• 【数据结构】搜索二叉树(C++实现)

    ​在这里插入图片描述

    ​📝个人主页：@Sherry的成长之路
    🏠学习社区：Sherry的成长之路（个人社区）
    📖专栏链接：数据结构
    🎯长路漫漫浩浩，万事皆有期待

    上一篇博客：【C++】C++模板进阶 —— 非类型模板参数、模板的特化以及模板的分离编译

    文章目录

    一、二叉搜索树的概念

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

    若它的左子树不为空，则左子树上所有的节点的值都小于根节点的值。
    若它的右子树不为空，则右子树上所有的节点的值都大于根节点的值。
    它的左右子树也分别为二叉搜索树。

    二、二叉搜索树的实现

    2.1 节点的定义及构造

    创建树之前必然要先定义好节点，跟之前普通链式二叉树没有什么区别。

    注意：

    ①我们会不断的通过 key 创建树节点， new 出的对象会调用带参的构造函数。所以，我们定义好节点中的成员变量后还要书写好构造函数。

    ②因为树节点会频繁访问成员变量，所以我们要将其置为公有成员(public)，如果觉得麻烦，可以直接使用 struct 定义节点。

    template <class K>
class BSTreeNode
{	
public:
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;
 
	//用 key 构造一个树节点
	BSTreeNode(const K& key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    2.2 树的结构及功能展示

    接下来看看 BSTree 类中的我们要实现的成员函数及变量定义。

    template <class K>
class BSTree
{
	typedef BSTreeNode<K> Node;

private:
	Node* _root = nullptr;

public:
       //默认成员函数
       BSTree ();
       BSTree (const K& key);
       BSTree& operator=(BSTree Tree);
       ~BSTree();
       
		bool Insert(const K& key);
		void Inorder();
		bool find(const K& key);
		bool Erase(const K& key);
	       
		//递归实现   
		bool FindR(const K& key);
		bool InsertR(const K& key);
		bool EraseR(const K& key);
   }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    2.3 树的 Insert

    首先，我们实现树的插入。我们要明确，这个插入要符合二叉搜索树的特性，即左子树的值小于根节点的值，右节点的值都大于根节点的值。

    共分为以下几种情况和步骤：

    传入空树直接 new 一个节点，将其置为 root 。
    找到 key 值该在的位置，如果 key 大于 当前节点的 _key，则往右走，小于则往左走。
    如果 key 等于当前节点的 _key，直接返回 false。
    直到 cur 走到空，此时 cur 指向的便是 key 应当存放的地方。
    创建一个节点并链接到树中(链接到 parent 节点的左或右)

    bool Insert(const K& key)
{
	//如果当前树为空
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _root;
	//直到 cur 指向 nullptr
	while (cur)
	{
		//cur->_key 小于 key 走右子树
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		//cur->_key 小于  走左子树
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		//cur->_key == key 不允许插入
		else
		{
			return false;
		}
	}
	//此时cur处于正确的位置。
	cur = new Node(key);
	//判断 key 应该在 parent 的左边还是右边
	if (parent->_key > key)
		parent->_left = cur;
	else
		parent->_right = cur;
	return true;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    2.4 树的中序遍历

    插入完成后，接下来我们就测试一下我们的代码。

    因为搜索树的规律为，左子树<根节点<右子树。所以说我们只要先打印左子树，在打印根节点，最后打印右子树，就可以按顺序输出树中存放的 key 值。

    而这个顺序正好对应我们二叉树中的中序遍历。接下来实现一个中序遍历

    void InOrder()
{
	_InOrder(_root);
	cout<<endl;
}
private:
void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}
	_InOrder(root->left);
	cout << root->_key << " ";
	_InOrder(root->right);
private:
	Node* _root;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    类中的递归函数并不容易被调用。如果我们直接使用 root 作为函数的 Insert 的参数，就不得不将_root 变为 公有成员

    2.4 树的 Find

    find 和 Insert 核心代码完全相同。

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    2.5 树的 Erase

    Erase 删除分为以下三种情况：

    删除节点为叶子节点
    删除节点有一个子节点
    删除节点有两个子节点

    情况一和情况二非常好解决，其本质都属于左或右节点为空，当该节点只有一个孩子或无孩子时，直接让 parent 指向该节点子节点，然后将此节点移除出树。

    我们先来解决前两种情况。其中有这几个点需要我们注意：

    1. 删除的是根节点

    如果parent指向的是nullptr，则直接让_root后移动即可。

    1. 链接时，应该链接到父亲的左还是右。

    如果parent的左边是待删节点，即parent->left==cur，则将cur的右边链接到parent的左边

    如果parent的右边是待删节点，即parent->right==cur，将cur的右边链接到parent的右边
    在这里插入图片描述

    代码如下(情况1、2的解决方法)：

    bool _Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	//找key
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		//找到存放 key的节点
		else
		{
			//key的左子树为空 所以父节点链接右子树
			if (cur->_left == nullptr)
			{
				//如果删除的是根节点，此时父节点指向为nullptr
				if (parent == nullptr)
				{
					//直接让_root指向下一个节点
					_root = _root->_right;
				}
				else
				{
					//判断应该链接到父节点的左还是右
					if (cur == parent->_left)
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
				}
				delete cur;
				cur=nullptr;
			}
			//key的右子树为空 所以父节点链接左子树
			else if (cur->_right == nullptr)
			{
				//删除的为根节点的情况
				if (parent == nullptr)
				{
					_root = _root->_left;
				}
				else
				{
					//判断应当链接到父节点的左还是右
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
				cur=nullptr;
			}
			//删除节点左、右都不为空
			else
			{
				
			}
			return true;
		}
	}
	return false;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73

    情况三采用的是替换法删除，我们观察下图，删除 3 的情况。

    在这里插入图片描述

    为什么会这样呢？我们结合搜索树的性质和中序遍历，中序遍历中打印根节点的上一个节点是左子树的最右节点，根节点的下一个节点是右子树的最左节点，这两个节点的值于根节点的值最相近，所以，这两个节点是替换根节点的最好节点，替换后能不破坏搜索树的结构。

    我们把 3 看作根为一棵搜索树

    左子树的最大节点——左子树的最右节点，即 2
    右子树的最小节点——右子树的最左节点，即 4

    所以这里我们找右子树的最小节点进行替换。

    此时我们开始编写代码，不考虑一些特殊情况。

    //删除节点左、右都不为空
else
   {
	Node* min = cur->_right;
	while (cur->_right == nullptr)
	{
		min = min->_left;
	}
	swap(cur->_key, min->_key);
	delete cur;
	cur=nullptr;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    接下来我们分析上面的代码会造成什么问题。

    1. 此时 6 节点的_left 仍然指向原来的 4 节点，出现野指针的问题。并且如果 4 节点还有右子树呢？如图：

    在这里插入图片描述

    1. 无法删除根节点(8)

    解决问题1：
    我们的方法是仍要记录下min的父节点，让父节点指向 min->right，此时无论min->right有子树还是min->right==nullptr，都可以很好的解决该问题，代码如下：

    在这里插入图片描述

    解决问题2：
    删除8节点，此时 min 指向了cur->right，min ->left 为空，没有进入循环，导致minparent 为空指针，指向 minparent->_left = min->right;出现非法访问。
    在这里插入图片描述

    所以我们要将minparent初始化为cur。如果删除8节点，min节点往下找右子树的最左节点，再让 parent 指向右子树的最左节点的右子树，此时就会破坏树的结构，如图：
    在这里插入图片描述

    所以，我们还是要判断，如果 min 在 minparent 的左子树，就改变minparent的左子树；如果 min在minparent的右子树，就改变minparent的右子树。

    在这里插入图片描述

    好的，这两个棘手的问题我们就顺利解决了，我们来看看整体的 Erase 代码。

    //删除
bool _Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	//找key
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		//找到存放 key的节点
		else
		{
			//key的左子树为空 所以父节点链接右子树
			if (cur->_left == nullptr)
			{
				//如果删除的是根节点，此时父节点指向为nullptr
				if (parent == nullptr)
				{
					//直接让_root指向下一个节点
					_root = _root->_right;
				}
				else
				{
					//判断应该链接到父节点的左还是右
					if (cur == parent->_left)
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
				}
				delete cur;
			}
			//key的右子树为空 所以父节点链接左子树
			else if (cur->_right == nullptr)
			{
				//删除的为根节点的情况
				if (parent == nullptr)
				{
					_root = _root->_left;
				}
				else
				{
					//判断应当链接到父节点的左还是右
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			//删除节点左、右都不为空
			else
			{
				//指向cur，防止非法访问
				Node* minparent = cur;
				Node* min = cur->_right;
				while (min->_left != nullptr)
				{
					minparent = min;
					min = min->_left;
				}
				swap(cur->_key, min->_key);
				//解决野指针或min->right有子树的情况
				//minparent->_left = min->_right;
				//判断min在minparent的左或右
				if (minparent->_left == min)
					minparent->_left = min->_right;
				else
					minparent->_right = min->_right;
				delete min;
			}
			return true;
		}
	}
	return false;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88

    2.6 拷贝构造、赋值运算符重载、析构函数

    析构函数

    与普通的二叉树Destory代码几乎一样。

    ~BSTree()
{
_Destory(_root);
}
private:
void _Destory (Node* root)
{
	if （root)
	{
		_Destory(root->_left);
		_Destory(root->_right);
		delete root;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    构造与拷贝构造函数函数

    拷贝构造函数就是根据前序构造出一棵树

    BSTree(const BSTree<K>& t)
{
	_root = _Copy(t._root);
}
private:
Node* _Copy (Node* root)
{
	if (root == nullptr)
	{
	return nullptr;
	}
	root = new Node(root->_key);
	root =_Copy(root->_left);
	root =_Copy(root->_right);
	return root;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    注意 如果写了默认拷贝构造函数编译器就不会默认生成构造函数了，所以这里我们也要提供一个默认构造函数或者强制编译器为我们默认生成一个构造函数。如下：

    public:
//C++11用法，作用:强制编译器生成默认的构造
BSTree(） = default;


    • 1
    • 2
    • 3
    • 4

    赋值运算符重载

    因为我们已经实现了拷贝构造函数，所以我们可以套用拷贝构造函数来实现赋值运算符重载。

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

    • 1
    • 2
    • 3
    • 4
    • 5

    三、递归实现树的增删查

    3.1 递归实现 FindR

    实现递归版本的 Find ，总共分4步：

    1.如果 root 指向为 nullptr ，说明未找到 key 值
    2.如果 key 大于 root->key，说明 key 在 root 的右边，使用root->right继续递归。
    3.如果 key 小于 root->key，说明 key 在 root 的左边，使用root->left继续递归。
    4.最后就是 key==root->key 的情况，返回 true 。

    代码如下：

    //Find的递归版本
bool FindR(const K& key)
{
	return _FindR(_root, key);
}
 
private:
bool _FindR(const Node* root, const K& key)
{
	if (root == nullptr)
		return false;
	if (root->_key < key)
	{
		_FindR(root->_right, key);
	}
	else if (root->_key > key)
	{
		_FindR(root->_left, key);
	}
	else
	{
		return true;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    3.2 递归实现 InsertR

    在实现了FindR之后，实现出InsertR应该不难，代码大致如下：

    bool InsertR(const K& key)
{
	return _InsertR(_root, key)
}
 
bool _InsertR(const 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
	{
		//已存在 key 不允许插入
		return false;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    可是，发现一个问题，这样的写法是无法修改外部实参的，即无法链入搜索树中，所以我们要采用引用传参或二级指针传参，这样才能实质修改外部的变量。

    root == nullptr 就将 key 链入树中，此时 root 为最后一个节点左或右子树的别名

    3.3 递归实现 EraseR

    递归删除的主题逻辑与上面大致相同。

    步骤如下：

    1.root == nullptr，则返回false，即未找到 key，删除失败

    2.如果root->_key 小于 key，递归走右子树，

    3.如果root->_key 大于 key，递归走左子树

    4.最后就是 root->key == key，则开始删除节点。

    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);
	}
	//找到key，删除
	else
	{
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    当已经找到key值，进行删除时

    1.如果左子树为空，则让root指向其右子树。如图：

    2.如果右子树为空，则让root指向左子树，如图：

    3.当左子树、右子树都不为空时，采用替换法删除，交换 key 值，然后删除被替换的节点。

    交换过后，我们要删除 key 节点此时要使用root->right再次调用 _EraseR，如果直接使用 _EraseR(key)，则会删除失败，因为树的结构已经被破坏。

    代码如下：

    bool EraseR(const K& key)
{
	return _EraseR(root, key);
}
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);
	}
	//找到key，删除
	else
	{
        //情况1、2要记录待删除的节点。
		Node* del = root;
		if (root->_left == nullptr)
		{
			root = root->_right;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;
		}
		//左右都有孩子
		else
		{
			Node* min = root->_right;
			while (min->_left)
			{
				min = min->_left;
			}
			swap(root->_key, min->_key);
			//这里不能直接调用erase,交换后，树的结构已经破坏，显示找不到key值
			//return EraseR(key); 
			return _EraseR(root->_right, key);
		}
		delete del;
		return true;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    四、二叉树搜索树的应用

    1.K模型：K模型即只有 key 作为关键码，结构中只需要存储 key 即可，关键码即为需要搜索到的值。

    比如： 给一个单词 word，判断该单词是否拼写正确，具体方法如下：
    以词库中所有单词集合中的每个单词作为key，构造一棵二叉搜索树
    在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

    2.KV模型：每一个关键码 key ，都有与之对应的值 value，即的键值对。该种方法式在现实生活中非常常见：
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；
    再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现的次数就是，就够成一种键值对。

    4.1 key 模型

    现在我们将二叉搜索树的K模型套入实际案例中，顺便练习编程能力。

    将要拼写的单词插入到二叉搜索树中，用户开始拼写单词，如果用户输入的单词在词库中并拼写正确，则输出"拼写正确"，否则输出"拼写错误"。代码如下：

    void testBSTree1()
{
	BSTree<string> WordTree;
	string arr[]={"left","right","string ","word","sort","insert"};
	for (auto &e : arr)
	{
		wordTree.Insert(e);
	}
	string str;
	while (cin >> str)
	{
		bool flag = wordTree.Find(str);
		if (flag)
		{
		cout<<"拼写正确”<<endl;
		}
		else
		{
		cout <<“拼写错误”<< endl;
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    4.2 key-value 模型

    我们现在创建一个字典，用户输入英文，程序打印出中文。

    首先我们要创建 key-value 模型，然后将值插入，通过查找key，然后输出其value值。注意，如果是k-value模型，find的返回值就应为节点的指针。

    我们看看代码是如何书写的，并且尝试运行一下：

    void testBSTree1()
{
	BSTreeustring, string> dict;
	dict. Insert("sort"，"排序");
	dict. Insert("left","左边");
	dict. Insert("right","右边");
	dict.Insert("string",“字符串");dict.Insert( "insert","插入");
	string str;
	while (cin >> str)
	{
		BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret)
		{
		cout <<“中文:”<<ret->_value<< endl;
		}
		else
		{
		cout<<"无此单词”<< endl;
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    通过key-value模型我们还可以实现统计次数的程序。

    例如我们往树中插入字符串，如果该字符串已存在，则++该字符串的计数。最后使用 Inorder 打印树中的元素，注意，要将Inorder中的输出语句带上value进行输出噢~

    代码及结果如下：

    void testBSTree2()
{
	string arr[] -{"苹果","苹果","草莓","苹果","菠萝","香蕉","香蕉","苹果","苹果","香蕉"};
	BSTree<string, int> countTree;
	for (auto& str : arr)
	{
		BSTreeNode<string,int>* ret = countTree.Find( str);
		if (ret)
		{
		ret->_value++;
		}
		else
		{
		countTree.Insert(str,1);
		}
	}
	countTree.Inorder();
]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

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

    在实现完功能之后，我们来对二叉搜索树进行性能分析。

    问：搜索二叉树增删查的时间复杂度为多少？

    答：最坏的情况下为 O(h) —— h为高度。

    为什么不是lgN，而是O(h) ，我们来看看如果树的形状是以下这几种情况的呢?

    在这里插入图片描述

    对有 n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度函数，即结点越深，比较次数越多。

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

    在这里插入图片描述

    最优情况下：二叉搜索树为完全二叉树(或接近完全二叉树)，其平均比较次数为 lgN.

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

    所以说，二叉搜索树的效率在这种情况下跟O(N)几乎没有区别。其本质是不平衡的，所以后面我们要学习AVL树和红黑树来保持平衡。这样，搜索的效率就会极高。

    在这里插入图片描述

    六、二叉搜索树(key、key-value)代码

    Key模型

    //节点的定义
template <class K>
class BSTreeNode
{
public:
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;
 
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
 
};
 
template <class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	//C++11用法，作用：强制编译器生成默认的构造
	BSTree() = default;
 
 
	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->_left = cur;
		else
			parent->_right = cur;
		return true;
	}
 
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
 
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
 
	bool _Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)
					{
						_root = _root->_right;
					}
					else
					{
						if (cur == parent->_left)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = _root->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					Node* minparent = cur;
					Node* min = cur->_right;
					while (min->_left != nullptr)
					{
						minparent = min;
						min = min->_left;
					}
					swap(cur->_key, min->_key);
					if (minparent->_left == min)
						minparent->_left = min->_right;
					else
						minparent->_right = min->_right;
					delete min;
				}
				return true;
			}
		}
		return false;
	}
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}
 
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
 
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
	~BSTree()
	{
		_Destory(_root);
	}
 	BSTree()
 	{}
 	BSTree()=defaut;//强制编译器生成默认的构造
	BSTree(const BSTree<K>& t)
	{
		_root = _Copy(t._root);
	}
 
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(t._root, _root);
		return *this;
	}
 
 
private:
	Node* _Copy(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* copyRoot = new Node(root->_key);
		copyRoot->_left = _Copy(root->_left);
		copyRoot->_right = _Copy(root->_right);
		return copyRoot;
	}
 
	void _Destory(Node* root)
	{
		if (root)
		{
			_Destory(root->_left);
			_Destory(root->_right);
			delete root;
		}
	}
	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);
		}
		//找到key，删除
		else
		{
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			//左右都有孩子
			else
			{
				Node* min = root->_right;
				while (min->_left)
				{
					min = min->_left;
				}
				swap(root->_key, min->_key);
				//这里不能直接调用erase,交换后，树的结构已经破坏，显示找不到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
		{
			//已存在 key 不允许插入
			return false;
		}
	}
 
 
	bool _FindR(const Node* root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			_FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			_FindR(root->_left, key);
		}
		else
		{
			return true;
		}
 
	}
 
	void _Inorder(Node* root)
	{
		if (root)
		{
			_Inorder(root->_left);
			cout << root->_key << " ";
			_Inorder(root->_right);
		}
	}
 
	Node* _root = nullptr;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314

    Key-Value模型

    Find、Insert函数做出相应修改，并删除了部分函数

    class BSTreeNode
{
public:
	BSTreeNode<K, Value>* _left;
	BSTreeNode<K, Value>* _right;
	K _key;
	Value _value;
	BSTreeNode(const K& key, const Value& value)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
		, _value(value)
	{}
 
};
 
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->_left = cur;
		else
			parent->_right = cur;
		return true;
	}
 
 
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
 
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
 
private:
	void _Inorder(Node* root)
	{
		if (root)
		{
			_Inorder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_Inorder(root->_right);
		}
	}
	Node* _root = nullptr;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95

    总结：

    今天我们比较详细地完成了搜索二叉树(的C++实现，了解了一些有关的底层原理。接下来，我们将进行STL中 set、map、multiset、multimap类的学习。希望我的文章和讲解能对大家的学习提供一些帮助。

    当然，本文仍有许多不足之处，欢迎各位小伙伴们随时私信交流、批评指正！我们下期见~

    在这里插入图片描述

  • 相关阅读:
    计算机毕业设计选题推荐-二手交易跳蚤市场微信小程序/安卓APP-项目实战
    K8s部署
    使用select实现服务器并发
    什么是Scrum？Scrum的核心要点和精髓
    Spring Cloud Gateway从数据库读取路由配置
    Kotlin基础从入门到进阶系列讲解（入门篇）Activity的使用
    Java入门,最全面最简单的Java基础教程
    情人节程序员用HTML网页表白【情人节爱你的代码】 HTML5七夕情人节表白网页源码 HTML+CSS+JavaScript
    ABAP内表操作
    ECCV 2022 | 知识可取可存！新加坡国立大学提出：全新可恢复型模型遗忘框架LIRF！...
  • 原文地址：https://blog.csdn.net/m0_73258399/article/details/130790313