C++笔记17•数据结构:二叉搜索树（K模型/KV模型实现）•

于 2024-09-04 20:13:47 发布
阅读量739 收藏 8
点赞数 8
文章标签： 笔记 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64446190/article/details/141902682
版权

二叉搜索树

1.二叉搜索树

1. 二叉搜索树的查找
a 、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b 、最多查找高度次，走到到空，还没找到，这个值不存在。
2. 二叉搜索树的插入
插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给 root 指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
3.二叉搜索树的删除
首先查找元素是否在二叉搜索树中，如果不存在，则返回 , 否则要删除的结点可能分下面四种情 况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有 4 中情况，实际情况 a 可以与情况 b 或者 c 合并起来，因此真正的删除过程如下：
情况 b ：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点 -- 直接删除
情况 c ：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点 -- 直接删除
情况 d：在它的右子树中寻找中序下的第一个结点（ 也就是删除节点的左子树中最大的值或者删除节点的右子树中最小的值 ），用它的值填补到被删除节点 中，再来处理该结点的删除问题 -- 替换法删除

删除9、16、3、10节点

其中：节点9和16可以直接删除。3、10节点需要用替换法删除

节点3：需要用2节点或7节点来替换

节点10：需要用9节点或12节点来替换

 2.二叉搜索树-K模型

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

//二叉搜索树BinarySearchTree
//struct BinarySearchTreeNode

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;//一定不要写成BSTreeNode*<K>  _left;  这样编译器无法识别
	BSTreeNode<K>* _right;
	K _key;

	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

template<class K>
class BSTree
{
	typedef struct BSTreeNode<K> Node;
public:
	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;
			}
		}

		//准备从parent插入
		Node* node = new Node(key);
		if (parent->_key > key)//插左子树
		{
			parent->_left = node;
		}
		else//插右子树
		{
			parent->_right = node;
		}
		//cur = new Node(key);
		//if (parent->_key > key)//插左子树
		//{
		//	parent->_left = cur;
		//}
		//else//插右子树
		//{
		//	parent->_right = 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;
	}
	void find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key == key)
			{
				cout << "找到了!" << endl;
				return;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
		}
		cout << "找不到!" << endl;
		return;
	}
	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   //找到了开始删除  1.左为空  2.右为空  3.左右都不为空
			{
				if (cur->_left == nullptr) //1.左为空
				{
					if (cur == _root) //判断删除的节点是否是根节点 根的左为空 让根的右成为根就可以了 _root = cur->_right
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else     //parent->_right == cur
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;                   //不要忘记手动释放节点
				}
				else if (cur->_right == nullptr)//2.右为空
				{
					if (cur == _root)//判断删除的节点是否是根节点 根的右为空 让根的左成为根就可以了 _root = cur->_left
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else   //parent->_right == cur
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else   //3.左右都不为空 用删除节点的左子树中最大的值或者删除节点的右子树中最小的值  此处用删除节点的左子树最大值
				{
					//Node* Lbignode_pre = nullptr;//不能置空 后面如果直接跳出循环Lbignode_pre还是空，会出bug；Lbignode_pre->_right  空指针不能这样访问
					Node* Lbignode_pre = cur;

					Node* Lbignode = cur->_left;

					while (Lbignode->_right)
					{
						Lbignode_pre = Lbignode;
						Lbignode = Lbignode->_right;
					}

					cur->_key = Lbignode->_key;//替换节点中的值，删除cur转换为删除Lbignode
					if (Lbignode == Lbignode_pre->_right)
					{
						Lbignode_pre->_right = Lbignode->_left;
					}
					else
					{
						Lbignode_pre->_left = Lbignode->_left;
					}

					delete Lbignode;
				}
				return true;
			}
		}
		return false;

	}

private:
	Node* _root = nullptr;
};

void test1()
{
	BSTree<int> bt;
	bt.insert(1);
	bt.insert(10);
	bt.insert(2);
	bt.insert(5);
	bt.insert(4);
	bt.insert(6);
	bt.insert(8);
	bt.insert(9);
	bt.insert(7);
	bt.insert(3);
	bt.insert(0);
	bt.insert(0);

	bt.Inorder();
	bt.find(8);
	bt.find(20);
	bt.erase(20);
	bt.erase(0);
	bt.erase(10);
	bt.erase(8);

	bt.Inorder();

}
void test2()
{
	char arr[] = { 10,9,8,7,6,5,4,3,2,1,0 };
	BSTree<int> bt;
	for (auto e : arr)
	{
		bt.insert(e);
	}
	cout << "插入:" << endl;
	bt.Inorder();
	cout << "依次删除:" << endl;
	for (auto e : arr)
	{
		bt.erase(e);
		bt.Inorder();
	}
}
int main()
{
	//test1();
	test2();
	return 0;

}

 3.二叉搜索树-KV模型

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
using namespace std;

//二叉搜索树BinarySearchTree
//struct BinarySearchTreeNode

template<class K,class V>
struct BSTreeNode
{
	BSTreeNode<K,V>* _left;//一定不要写成BSTreeNode*<K>  _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 struct 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;
			}
		}

		//准备从parent插入
		Node* node = new Node(key, value);
		if (parent->_key > key)//插左子树
		{
			parent->_left = node;
		}
		else//插右子树
		{
			parent->_right = node;
		}
		//cur = new Node(key, value);
		//if (parent->_key > key)//插左子树
		//{
		//	parent->_left = cur;
		//}
		//else//插右子树
		//{
		//	parent->_right = 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)
			{
				//cout << "找到了!" << endl;
				return cur;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
		}
		//cout << "找不到!" << endl;
		return nullptr;
	}
	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   //找到了开始删除  1.左为空  2.右为空  3.左右都不为空
			{
				if (cur->_left == nullptr) //1.左为空
				{
					if (cur == _root) //判断删除的节点是否是根节点 根的左为空 让根的右成为根就可以了 _root = cur->_right
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else     //parent->_right == cur
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;                   //不要忘记手动释放节点
				}
				else if (cur->_right == nullptr)//2.右为空
				{
					if (cur == _root)//判断删除的节点是否是根节点 根的右为空 让根的左成为根就可以了 _root = cur->_left
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else   //parent->_right == cur
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else   //3.左右都不为空 用删除节点的左子树中最大的值或者删除节点的右子树中最小的值  此处用删除节点的左子树最大值
				{
					//Node* Lbignode_pre = nullptr;不能置空 后面如果直接跳出循环Lbignode_pre还是空，会出bug；Lbignode_pre->_right  空指针不能这样访问
					Node* Lbignode_pre = cur;

					Node* Lbignode = cur->_left;

					while (Lbignode->_right)
					{
						Lbignode_pre = Lbignode;
						Lbignode = Lbignode->_right;
					}

					cur->_key = Lbignode->_key;//替换节点中的值，删除cur转换为删除Lbignode
					if (Lbignode == Lbignode_pre->_right)
					{
						Lbignode_pre->_right = Lbignode->_left;
					}
					else
					{
						Lbignode_pre->_left = Lbignode->_left;
					}

					delete Lbignode;
				}
				return true;
			}
		}
		return false;

	}

private:
	Node* _root = nullptr;
};

void test1()
{
	BSTree<string,string> Dictionary;
	Dictionary.insert("apple", "苹果");
	Dictionary.insert("pear", "梨");
	Dictionary.insert("left", "左");
	Dictionary.insert("right", "右");
	string str;
	while (cin >> str)
	{
		BSTreeNode<string, string>* ret = Dictionary.find(str);
		if(ret)
			cout << ret->_value << endl;
		else
			cout << "词典没有此单词！" << endl;
	}
	
}
void test2()
{
	string arr[] = { "徐香猕猴桃","葡萄", "梨", "哈密瓜", "西瓜", "苹果", "橙子", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉"};
	BSTree<string, int> countfruit;
	BSTreeNode<string, int>* ret =nullptr;
	for (auto e : arr)
	{
		//BSTreeNode<string, int>* ret =countfruit.find(e);
		ret = countfruit.find(e);
		if (ret == nullptr)
			countfruit.insert(e, 1);
		else
			ret->_value++;
	}
	delete ret;//这里可能会有双重释放节点 ret属于树节点 应在树中析构函数中进行节点的释放的管理，这里一般不需要自己手动释放，自己释放可能会遇到内存泄漏
	countfruit.Inorder();
	delete ret;
}
int main()
{
	//test1();
	test2();
	return 0;

}

Wise cas429
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值