【C++】---二叉搜索树

最新推荐文章于 2024-07-18 23:31:00 发布
最新推荐文章于 2024-07-18 23:31:00 发布
阅读量1.7k 收藏 49
点赞数 75
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_75128035/article/details/139299798
版权

【C++】---二叉搜索树

在这里插入图片描述

一、二叉搜索树概念

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

  1. 如果它的左子树不为空，那么左子树上所有节点的值都小于根结点的值。
  2. 如果它的右子树不为空，那么右子树上所有节点的值都大于根节点的值。
  3. 它的左右子树也是二叉搜索树。

在这里插入图片描述

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

比如说：这个数组都可以将它化为二叉搜索树

在这里插入图片描述

总结：在左子树值比根小，右子树值比根大。 当树走中序遍历时，序列都是有序的。

二叉搜索树 的 结构定义：


#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;
private:
	Node* _root;
public:

	BSTree()
		:_root(nullptr)
	{

	}
};

二、二叉搜索树操作（非递归）

1.二叉搜索树的查找 （非递归）

利用二分查找的方法，借助我们去二叉搜索树中查找节点。

在这里插入图片描述
在这里插入图片描述
查找的时间复杂度：最坏的情况，就是查找高度（h=logN）次，就可以判断一个值在不在节点里面。

（1）查找

查找的思路：

  1. key比当前结点的值小，往左走！
  2. key比当前结点的值大，往右走！
  3. key==当前结点的值，就找到了！

在这里插入图片描述

// 查找：
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;// 找到了！
			}
		}
		return nullptr;// 遍历完了，都还没找到！
	}

（2）中序遍历

由于根节点_root是私有成员变量，如果在main函数里面来进行中序遍历的话，这就是在类外对私有成员进行访问，这是不合法的！

所以说我们要解决这个问题，可以用这样：
在类的public内的 中序遍历 InOrder 里面 再套一层私有的中序遍历：_InOrder，这样，_InOrder身为私有函数，就可以访问：私有变量_root！

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << endl;
		_InOrder(root->_right);
	}
public:
	
	// 中序遍历：
	void InOrder() //这个函数 类外可以直接访问！
	{
		_InOrder(_root); // 这个函数，是 私有函数 对 私有成员 的访问！
		cout << endl;
	}

2.二叉搜索树的插入（非递归）

插入节点分两步：

（1）找位置

    ①key比当前节点值大，向左走

    ②key比当前节点值小，向右走

    ③key等于当前节点值，该节点值已经存在，插入失败

（2）插入

    ①key比父亲节点值小就插入父亲左子树

    ②key比父亲节点值大就插入父亲右子树

由于插入后，要将节点链接到树中，因此要定义parent节点，用来链接新节点：

在这里插入图片描述

// 插入：
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		// (1) 找到插入的位置
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;// 二叉搜索树不允许数据冗余！
			}
		}

		cur = new Node(key);

		// (2) 判断
		if (key<parent->_key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}

3.二叉搜索树的删除（非递归）

非递归删除：

（1）找位置

    ①key比当前节点值大，向左走

    ②key比当前节点值小，向右走

    ③key等于当前节点值，找到了，准备删除

（2）删除，有两种删除方法：非递归和递归

    非递归删除: 

    ①该节点没有孩子，即该节点是叶子节点，删除节点后把父亲指向自己的指针置空

在这里插入图片描述

    ②该节点有一个孩子，就把该节点的孩子节点的链接给该节点的父亲，顶替自己的位置，
    ①可以当成②的特殊情况

在这里插入图片描述

    ③该节点有两个孩子，找比它自己的左孩子大，比它自己的右孩子小的节点替换它
    （也就是拿它的左子树的最大节点或右子树的最小节点替换它），
    替换之后，该节点就只有一个孩子或没有孩子了，就变成①或②了。

在这里插入图片描述

// 删除
	bool erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		// (1) 找到插入的位置
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				break;
			}
		}
		// 1、2、 (子 代替 父亲的位置)

		// 大前提：如果要删除的节点，left为空
		if (cur->_left == nullptr)
		{
			// 如果要删除根！
			if (cur == _root)
			{
				_root = cur->_right;// 那就让cur的右当根
			}
			// 如果要删除的不是根！
			else
			{
				// 如果要删除的节点cur，在父亲的左边。

				// 因为是替代法，所以说要让 子 的位置代替 父亲 的位置，但是 子 的位置只有_right存在，所以说会把_right的位置放到即将要删除cur的位置。
				if (parent->_left == cur)
				{
					parent->_left = cur->_right;
				}
				else
				{
					parent->_right = cur->_right;
				}
			}

			delete cur;
		}


		// 大前提：如果要删除的节点，right为空
		else if (cur->_right == nullptr)
		{
			if (cur == _root)
			{
				_root = cur->_left;
			}

			else
			{
				// 因为是替代法，所以说要让 子 的位置代替 父亲 的位置，但是 子 的位置只有_left存在，所以说会把_left的位置放到即将要删除cur的位置。
				if (parent->_left == cur)
				{
					parent->_left = cur->_left;
				}
				else
				{
					parent->_right = cur->_left;
				}
			}
			delete cur;
		}

		// 3、要删除的cur不只有一个节点。可能有多个节点，甚至整个指子树
		// 找到要删除节点cur，左子树最大的节点，右子树最小的节点，来代替cur的位置。
		else
		{
			// 要么找cur左子树中的max，要么就找右子树中的min

			// 这里 以 RightMin为例！

			// (1)找到 RightMin (就像找 cur那样)
			Node* RightMin = cur->_right;
			Node* RightMinParent = cur; // 定义 RightMinParent 为了方便后续节点的连接。

			while (RightMin->_left)
			{
				RightMinParent = RightMin;
				RightMin = RightMin->_left;
			}
			// (2)找到了 就交换！
			swap(RightMin->_key, cur->_key);

			// (3) 交换完后 就链接！

			if (RightMinParent->_left == RightMin)
				RightMinParent->_left = cur;
			else
				RightMinParent->_right = cur;
			// 链接完成！

			delete cur;
		}

		return true;
	}

递归删除：

相对于非递归，只需要修改找到了要修改的代码：找到了后不需要管cur到底左为空、右为空、还是左右都不为空

① 找要删除节点的右子树的最小节点并把它的值保存起来

② 删除右子树的最小节点

③ 把要删除的节点值替换成右子树的最小节点值

在这里插入图片描述

                else//左右都不为空，替换法删除
                {
					//找右子树最小节点
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						minRight = minRight->_left;
					}
 
					//用min保存右子树最小节点的值
					K min = minRight->_key;
 
					//递归调用自己去替换删除节点，一定会走到左为空的情况处理
					this->Erase(min);
 
					//删除完毕替换节点之后，把cur的值替换成min
					cur->_key = min;
				}

三、二叉搜索树操作（递归）

理解了非递归操作以后， 递归操作就很简单了：

#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:
	//递归查找
	Node* 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);
	}
private:
	Node* _root;
};

由于_root是私有的，可以把递归子函数查找、插入、删除都定义成私有的

1.二叉搜索树的查找（递归）

private:
    //查找
	Node* _FindR(Node* root, const K& key)
	{
		if (root == nullptr)//没找到
		{
			return nullptr;
		}
 
		if (key < root->_key)//到左子树去找
		{
			FindR(root->_left, key);
		}
		else if (key > root->_key)//到右子树去找
		{
			FindR(root->_right, key);
		}
		else//找到了
		{
			return root;
		}
	}

2.二叉搜索树的插入（递归）

	//插入 加了&，root是_root的别名，修改root就直接修改到上一层调用，不用找父亲
	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)//找到位置了
		{
			root = new Node(key);
			return true;
		}
		if (key < root->_key)//到左子树去找位置
		{
			_InsertR(root->_left, key);
		}
		else if (key > root->_key)//到右子树去找位置
		{
			_InsertR(root->_right, key);
		}
		else//已存在，无需插入
		{
			return false;
		}
	}

3.二叉搜索树的删除（递归）

递归删除：和二叉树的删除（非递归）一样，找到后的删除也有两种方式，递归和非递归

找到后的非递归删除：

    //插入 加了&，root是_root的别名，修改root就直接修改到上一层调用，不用找父亲	
    bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)//没找到
		{
			return false;
		}
		if (key < root->_key)//到左子树去找
		{
			_EraseR(root->_left, key);
		}
		else if (key > root->_key)//到右子树去找
		{
			_EraseR(root->_right, key);
		}
		else
		{
			//找到了，root就是要删除的节点
			if (root->_left == nullptr)//root左为空
			{
				Node* del = root;
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)//root右为空
			{
				Node* del = root;
				root = root->_left;
				delete del;
			}
			else//root左右都不为空
			{
				//找到右子树最左节点替换
				Node* minParent = root;
				Node* minRight = root->_right;
 
				while (minRight->_left)
				{
					minParent = minRight;
					minRight = minRight->_left;
				}
 
				//保存替换节点的值
				cur->_key = minRight->_key;
 
				//链接
				if (minParent->_left == minRight)
				{
					minParent->_left = minRight->_right;
				}
				else
				{
					minParent->_right = minRight->_right;
				}
 
				//删除
				delete minRight;
			}
			return true;
		}
	}

找到后的递归删除：

			else//root左右都不为空
			{				
                //找右子树最左节点
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
 
				//保存右子树最左节点的值
				K min = minRight->_key;
 
				//使用递归方法删除右子树最左节点
				_Erase(root->_right, min);
			}

四、二叉搜索树的默认成员函数

现在还剩下二叉搜索树的构造、拷贝构造、赋值运算符重载、析构函数。

1.构造

public:
	//构造函数需要将根初始化为空就行了
	BSTree()
		:_root(nullptr)
	{}

2.拷贝构造

拷贝构造利用递归调用子函数不断拷贝节点:

	//拷贝构造
	BSTree(const BSTree<K>& t)
	{
		_root = t.copy(t._root);
	}

在子函数处:

	Node* _copy(Node* root)
	{
		if (root == nullptr)//如果根为空，直接返回
		{
			return;
		}
 
		Node* copyNode = new Node(root->_key);//创建根节点
		copyNode->_left = _copy(root->_left);//递归拷贝左子树节点
		copyNode->_right = _copy(root->_right);//递归拷贝右子树节点
		
		return copyNode;//返回根
	}

3.赋值运算符重载

借助拷贝构造用现代写法写:

	//赋值运算符重载(现代写法)
	BSTree& operator=(const BSTree<K>& t)
	{
		swap(_root,t._root);
		return *this;
	}

4.析构

递归调用子函数去析构

	//析构
	~BSTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}

在子函数处:

	_Destroy(root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}

五、K模型和KV模型搜索树

1.K模型搜索树

K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
1、以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
2、在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2.KV模型搜索树

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

1、比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
2、再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对。

改造二叉搜索树为KV结构的代码

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

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

		// pair<K, V> _kv;

		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:
		// logN
		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 cur;
		}

		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
				{
					// 删除
					// 左为空，父亲指向我的右
					if (cur->_left == nullptr)
					{
						//if(parent == 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(parent == 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* rightMinParent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}

						swap(cur->_key, rightMin->_key);

						if (rightMinParent->_left == rightMin)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;

						delete rightMin;
					}

					return true;
				}
			}

			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};

六、二叉搜索树性能分析

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！
在这里插入图片描述

小能软糖_
关注
  • 75
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 39
    评论
专栏目录
C++---二叉搜索树
qq_47406941的博客
05-19 622
一、二叉搜索树的概念 二叉搜索树又称二叉排序树，它是一颗空树或者是具有以下性质的树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、二叉搜索树的操作 1、查找 基本思路： 根节点为空，返回false 根节点不为空，比较根节点和要找的值是否相等，相等返回true。 根节点和要找的值不想等时，判断跟节点和要找的值的关系。 如果根节点小于要找到的值，则在右子树找 如果根节点大于要
C++编程-二叉搜索树的插入
weixin_43979090的博客
04-27 255
题目： 给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。 示例 1： 输入：root = [4,2,7,1,3], val = 5 输出：[4,2,7,1,3,5] 解释：另一个满足题目要求可以通过的树是： 示例 2： 输入：root = [40,20,60,10
C++--二叉搜索树
qq_46659987的博客
05-16 329
二叉搜索树1. 二叉搜索树2. 二叉搜索树的操作2.1 二叉搜索树的查找2.2 二叉搜索树的插入2.3 二叉搜索树的删除3. 二叉搜索树的性能分析 1. 二叉搜索树 二叉搜索树又称二叉排序树， 性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别是二叉搜索树； 可以是一棵空树。 2. 二叉搜索树的操作 二叉树的结构 template<class T> struct BNode { T
C++------利用C++实现二叉搜索树【数据结构】
m0_67635008的博客
08-20 593
算法思想：二叉搜索树的查找算法是这样的，从根的地方开始找，如果要找的key比根大就到右子树去找，如果比根小就到左子树找。我们要使树的高度保持为logN就必须引入平衡二叉搜索树的概念，这个部分我们在后面的AVL和红黑树部分讲解。情况d：在它的左子树中寻找最大节点，用它的值填补到被删除节点中，再来处理该节点的删除问题—替换法删除。情况b：删除该节点且是被删除节点的双亲节点指向被删除节点的左孩子节点—直接删除。情况c：删除该节点且是被删除节点的双亲节点指向被删除节点的右孩子节点—直接删除。好的我们下一篇再见！
C++进阶----二叉搜索树
weixin_63219391的博客
05-06 924
二叉搜索树
7-1 是否同一棵二叉搜索树 (34 分)
m0_61528957的博客
04-18 511
7-1 是否同一棵二叉搜索树 (34 分) 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N(≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。.
7-6 是否同一棵二叉搜索树
国家一级致癌物
11-17 409
7-6 是否同一棵二叉搜索树 (25 分) 附带样例解析 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插
【C++】二叉搜索树
qq_62939852的博客
04-18 927
从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。 最多查找高度次，走到到空，还没找到，这个值不存在非空右子树的所有值大于根节点的值 左右子树都是二叉搜索树第一个不满足，因为值为5的节点在值为10的节点的右边，正常来说10的右边都应该比10大分为两种情况 若插入的值在二叉树中不存在，则通过比较进行插入若插入11，因为11比8大，所以跟10比较，而11比10大，所以走10的右子树14，14与11比较，因14>11，所以走14的左子树13，11与13比较，因13>11，故作为13的左子树，遇见NU
C++进阶--二叉树进阶（二叉搜索树）
sushang的博客
12-30 917
二叉树进阶（二叉搜索树）一、二叉搜索树1.1 二叉搜索树的概念二、二叉搜索树的结构2.1 结点结构2.2 树结构三、二叉搜索树的操作（非递归）3.1 二叉搜索树的插入3.2 二叉搜索树的查找3.3 二叉搜索树的中序遍历3.4 二叉搜索树的删除四、二叉搜索树的操作（递归）4.1 二叉搜索树的查找4.2 二叉搜索树的插入4.3 二叉搜索树的删除五、其他相关成员函数的实现5.1 析构函数5.2 构造和拷贝构造5.3 赋值重载6、二叉搜索树的应用6.1 K模型6.2 KV模型6.3 KV模型代码实现6.3.1 将二
C++ 之二叉搜索树
qq_74732628的博客
04-24 591
详解c++ 二叉搜索树的实现以及功能
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
binary-search-tree:二叉搜索树 OOP 的简单 C++ 实现
06-27
在这个名为"binary-search-tree:二叉搜索树 OOP 的简单 C++ 实现"的项目中，我们可以预期源代码将采用面向对象编程（Object-Oriented Programming，OOP）的方式来设计和实现二叉搜索树。C++ 是一种支持 OOP 的编程...
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
二叉查找树 减治法——C++代码
05-24
在二叉查找树的应用中，减治法通常用于递归地处理树的结构，例如在搜索、插入和删除操作中，我们首先比较目标值与当前节点的键，然后根据比较结果决定是在左子树还是右子树继续操作。 在C++中实现二叉查找树，一般...
shujujiegou__c++.rar_kruskal_二叉搜索树
09-21
本压缩包文件"shujujiegou__c++.rar_kruskal_二叉搜索树"包含了几个重要的数据结构和算法的C++实现，主要关注的是Kruskal算法以及二叉搜索树。 首先，我们来详细了解一下二叉搜索树（Binary Search Tree, BST）。...
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1077
c++ primer plus 第16章string 类和标准模板库,string 类输入。
C++ 继承篇
最新发布
2301_79201049的博客
07-18 333
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
c++ 生成随机字符串
m0_56306892的博客
07-15 209
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 144
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
L2-004 这是二叉搜索树吗？C++
08-15
根据引用的定义，二叉搜索树具有以下性质： 1. 任一节点的左子树中所有节点的键值小于该节点的键值； 2. 任一节点的右子树中所有节点的键值大于等于该节点的键值； 3. 任一节点的左右子树都是二叉搜索树。 根据引用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 39
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小能软糖_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值