C++学习__13—二叉树

羽t

已于 2024-06-28 17:58:17 修改

阅读量635

点赞数 28

分类专栏： C++学习文章标签：开发语言 c++ 学习

于 2024-06-25 14:38:35 首次发布

本文链接：https://blog.csdn.net/dfggc/article/details/139901954

版权

C++学习专栏收录该内容

14 篇文章 0 订阅

订阅专栏

[ 本节目标 ]
1. 内容安排说明
2. 二叉搜索树

1. 内容安排说明

二叉树在前面 C 数据结构阶段已经讲过，本节取名二叉树进阶是因为：
1. map 和 set 特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构
2. 二叉搜索树的特性了解，有助于更好的理解 map 和 set 的特性
3. 二叉树中部分面试题稍微有点难度，在前面讲解大家不容易接受，且时间长容易忘
4. 有些 OJ 题使用 C 语言方式实现比较麻烦
因此本节借二叉树搜索树，对二叉树部分进行收尾总结。

2. 二叉搜索树

2.1 二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

2.2 二叉搜索树操作

2.2.1. 二叉搜索树的查找

2.2.2. 二叉搜索树的插入

插入的具体过程如下：
a. 树为空，则直接插入

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

2.2.3. 二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：
情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，
再来处理该结点的删除问题

2.3 二叉搜索树的实现

#pragma once
#include<iostream>
using namespace std;
template<class K>
struct BSTreeNode
{
	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:
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* parent = _root;
		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 = _root;
		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 (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)
							parent->_right = cur->_right;
						else
							parent->_left = cur->_right;
					}
					delete cur;
				}
				else
				{
					// 修改
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					// 替代删除
					cur->_key = rightMin->_key;

					// 转换成删除rightMin(rightMin是左为空，父亲指向它的右)
					if (rightMin == rightMinParent->_left)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
				}
				return true;
			}
		}
		return false;
	}
	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);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
};

测试：

	BSTree<int> tree;
	tree.Insert(1);
	tree.Insert(4);
	tree.Insert(3);
	tree.Insert(6);
	tree.InOrder();
	if (tree.Find(5))
		cout << "ok";
	else
		cout << "no";
	tree.InOrder();

2.4 二叉搜索树的应用

1. K模型：K 模型即只有 key 作为关键码，结构中只需要存储 Key 即可，关键码即为需要搜索到的值。
比如：给一个单词 word，判断该单词是否拼写正确，具体方式如下：
以单词集合中的每个单词作为 key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
2. K V 模型：每一个关键码 key，都有与之对应的值 Value，即 < Key, Value > 的键值对。该种方式在现实生活中非常常见：比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文 < word, chinese > 就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是 < word, count >就构成一种键值对。
比如：实现一个简单的英汉词典 dict，可以通过英文找到与其对应的中文，具体实现方式如下：
< 单词，中文含义 > 为键值对构造二叉搜索树，注意：二叉搜索树需要比较，键值对比较时只比较
Key 查询英文单词时，只需给出英文单词，就可快速找到与其对应的 key

#pragma once
#include<iostream>
using namespace std;
#include<string>
#include<vector>
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)
		:_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 = _root;
		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;
	}
	bool Erase(const K& key)
	{
		Node* parent = _root;
		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 (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)
							parent->_right = cur->_right;
						else
							parent->_left = cur->_right;
					}
					delete cur;
				}
				else
				{
					// 修改
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					// 替代删除
					cur->_key = rightMin->_key;

					// 转换成删除rightMin(rightMin是左为空，父亲指向它的右)
					if (rightMin == rightMinParent->_left)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
				}
				return true;
			}
		}
		return false;
	}
	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(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << ":" << root->_value << endl;
		_InOrder(root->_right);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
};

测试：

	BSTree<string, string> tree;
	tree.Insert("sort", "排序");
	tree.Insert("string", "字符串");
	tree.Insert("slim", "苗条");
	string s;
	while (cin >> s)
	{
		auto* cur = tree.Find(s);
		if(cur)
		cout << cur->_value << endl;
	}
	vector<string> s = { "啊","额","啊","额","给","的","额","发"};
	BSTree<string, int> tree;
	for (auto i : s)
	{
		if (tree.Find(i))
			tree.Find(i)->_value++;
		else
			tree.Insert(i, 1);
	}
	tree.InOrder();

2.5 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有 n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为： $\log 2N$
最差情况下，二叉搜索树退化为单支树，其平均比较次数为： $\frac{N}{2}$

问题:如果退化成单支树，二又搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码都可以是二又搜索树的性能最佳?
答案后序课件讲解

羽t

关注

28
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
C++学习__13—二叉树

对有 n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。通过英文可以快速找到与其对应的中文，英文单词与其对应的中文 < word, chinese > 就构成一种键值对；< 单词，中文含义 > 为键值对构造二叉搜索树，注意：二叉搜索树需要比较，键值对比较时只比较。在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。，统计成功后，给定单词就可快速找到其出现的次数，该种方式在现实生活中非常常见：比如。
复制链接

扫一扫