【C++ 第十二章】二叉搜索树

最新推荐文章于 2024-10-03 23:25:47 发布
最新推荐文章于 2024-10-03 23:25:47 发布
阅读量1k 收藏 22
点赞数 28
分类专栏： C++修炼之路 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79499548/article/details/141329686
版权

1.1 二叉搜索树概念


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

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

1.2 二叉搜索树操作

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

0. 二叉搜索树节点的创建 与 基础框架的构建

节点类

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

	K _key;
	Node* _left;
	Node* _right;

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

基础框架

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

public:


private:
	Node* _root = nullptr;
};

1. 二叉搜索树的查找  find


a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。

// 1、查找
bool Find(const K& val) {
	if (_root == nullptr) {
		return false;
	}

	Node* cur = _root;
	while (cur) {
		if (cur->_key > val) {
			cur = cur->_left;
		}
		else if (cur->_key < val) {
			cur = cur->_right;
		}
		else return true;
	}

	return false;
}

 
2. 二叉搜索树的插入  insert


插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给 root 指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

Node* Insert(const K& val) {
	// （1）先判断节点是否存在
	if (Find(val)) {
		cout << "结点已存在" << '\n';
		return _root;
	}
	// （2）如果根为空，则直接插入一个节点
	if (_root == nullptr) {
		_root = new Node(val);
		return _root;
	}

	// （3）按照二叉搜索树的性质，走到合适的位置
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur) {
		if (cur->_key > val) {
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < val) {
			parent = cur;
			cur = cur->_right;
		}
	}

	// （4）插入节点：和父节点链接上
	cur = new Node(val);
	if (parent->_key > val) {
		parent->_left = cur;
	}
	else if (parent->_key < val) {
		parent->_right = cur;
	}

	return _root;
}

3. 二叉搜索树的删除

代码逻辑：

（1）先判断该节点是否存在：如果不存在，则返回

（2）按照搜索树的规则，找到目标节点位置

（3）分情况执行删除操作：

要删除的结点可能分下面四种情况：

a. 要删除的结点无孩子结点：没有孩子

b. 要删除的结点只有左孩子结点：只有 左孩子

c. 要删除的结点只有右孩子结点：只有 右孩子

d. 要删除的结点有左、右孩子结点：有左右孩子

看起来有待删除节点有 4 种情况，实际情况 a 可以与情况 b 或者 c 合并起来

因此真正的删除过程 如下：

⭐有一个孩子 或 零个孩子：

  • 情况1：删除该节点，使该节点的 父亲 指向 该节点的左孩子
  • 情况2：删除该节点，使该节点的 父亲 指向 该节点的右孩子

⭐有两个孩子：

  • 情况 3：替换法（删掉一个节点，可以找一个继承人继承你当前的位置）

你当前的位置有个特征：左边节点一定比你小，右边节点一定比你大

因此，你找的继承人一定也要满足这个条件：即可以是 左子树的最大节点 或 右子树的最小节点

  • 左子树的最大节点：一定比左子树的根要大，一定比右子树的根要小
  • 右子树的最小节点：一定比左子树的根要大，一定比右子树的根要小

替换规则：

        直接将要删除的节点的键值key 替换成 继承人的键值key，然后删除继承人（因为继承人一定是叶子节点，可以直接删除，不用处理是否有孩子的问题）

替换法 使得删除节点变得简单，而便利

代码中有详细的 步骤解释了

// 3、删除
void Erase(const K& val) {
	// （1）先看节点是否存在
	if (!Find(val)) {
		cout << "结点不存在" << '\n';
		return;
	}

	// （2）按照搜索树的规则，找到目标节点位置
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur) {
		if (cur->_key > val) {
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < val) {
			parent = cur;
			cur = cur->_right;
		}
		else break;
	}

	// （3）分情况执行删除操作：
	// 0~1个孩子：删除该节点后，让父节点指向我的孩子
	if (cur->_right == nullptr) {

		// 特殊情况：当父亲为空时，证明当前要删除的节点是根，直接删除，让根指针指向孩子
		if (parent == nullptr) {
			_root = cur->_left;
		}
		else {
			if (parent->_key > cur->_key) {
				parent->_left = cur->_left;
			}
			else if (parent->_key < cur->_key) {
				parent->_right = cur->_left;
			}
		}
		delete cur;
	}
	else if (cur->_left == nullptr) {
		if (parent == nullptr) {
			_root = cur->_right;
		}
		else {
			if (parent->_key > cur->_key) {
				parent->_left = cur->_right;
			}
			else if (parent->_key < cur->_key) {
				parent->_right = cur->_right;
			}
		}
		delete cur;
	}


	// 2 个孩子 及以上：替换法
	// 我们这里继承人是 ：右子树的最左节点
	else {
		// 删除 右子树的最左节点
		Node* MinR_parent = cur;  // 右子树的最左节点的 父节点：这里一定要赋值为 cur，不能赋值为 nullptr
		Node* MinRight = cur->_right; // 右子树的根

		while (MinRight->_left) {
			MinR_parent = MinRight;
			MinRight = MinRight->_left;
		}

		// 继承 cur 的位置
		cur->_key = MinRight->_key;


		// 删掉继承人，同时父节点接管 cur 的右孩子（为什么一定是右孩子：因为我们本代码要删除 右子树的最左节点，因此你就是最左的节点了，不可能还存在左节点）
		// 这里的问题是：Min 不知道是 MinParent的 左孩子 or 右孩子
		if (MinR_parent->_right == MinRight) {
			MinR_parent->_right = MinRight->_right;  // 可以是 空，也可以是一个节点
		}

		else MinR_parent->_left = MinRight->_right;  // 可以是 空，也可以是一个节点
		delete MinRight;
	}
}

4. 二叉树的中序遍历（便于观察结果）

void _InorderSearch(Node* root) {
	if (root == nullptr) {
		return;
	}
	_InorderSearch(root->_left);
	cout << root->_key << ' ';
	_InorderSearch(root->_right);
}

1.3 总代码 BinarySearchTree.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;


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

	K _key;
	Node* _left;
	Node* _right;

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

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

public:
	// 1、查找
	bool Find(const K& val) {
		if (_root == nullptr) {
			return false;
		}

		Node* cur = _root;
		while (cur) {
			if (cur->_key > val) {
				cur = cur->_left;
			}
			else if (cur->_key < val) {
				cur = cur->_right;
			}
			else return true;
		}

		return false;
	}
	// 2、插入
	Node* Insert(const K& val) {
		// （1）先判断节点是否存在
		if (Find(val)) {
			cout << "结点已存在" << '\n';
			return _root;
		}
		// （2）如果根为空，则直接插入一个节点
		if (_root == nullptr) {
			_root = new Node(val);
			return _root;
		}

		// （3）按照二叉搜索树的性质，走到合适的位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_key > val) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < val) {
				parent = cur;
				cur = cur->_right;
			}
		}

		// （4）插入节点：和父节点链接上
		cur = new Node(val);
		if (parent->_key > val) {
			parent->_left = cur;
		}
		else if (parent->_key < val) {
			parent->_right = cur;
		}

		return _root;
	}
	// 3、中序遍历：直接就是排序了


	void InorderSearch() {
		_InorderSearch(_root);
		cout << '\n';
	}
	// 4、删除
	void Erase(const K& val) {
		// （1）先看节点是否存在
		if (!Find(val)) {
			cout << "结点不存在" << '\n';
			return;
		}
		
		// （2）按照搜索树的规则，找到目标节点位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_key > val) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < val) {
				parent = cur;
				cur = cur->_right;
			}
			else break;
		}

		// （3）分情况执行删除操作：
		// 0~1个孩子：删除该节点后，让父节点指向我的孩子
		if (cur->_right == nullptr) {

			// 特殊情况：当父亲为空时，证明当前要删除的节点是根，直接删除，让根指针指向孩子
			if (parent == nullptr) {
				_root = cur->_left;
			}
			else {
				if (parent->_key > cur->_key) {
					parent->_left = cur->_left;
				}
				else if (parent->_key < cur->_key) {
					parent->_right = cur->_left;
				}
			}
			delete cur;
		}
		else if (cur->_left == nullptr) {
			if (parent == nullptr) {
				_root = cur->_right;
			}
			else {
				if (parent->_key > cur->_key) {
					parent->_left = cur->_right;
				}
				else if (parent->_key < cur->_key) {
					parent->_right = cur->_right;
				}
			}
			delete cur;
		}


		// 2 个孩子 及以上：替换法
		// 我们这里继承人是 ：右子树的最左节点
		else {
			// 删除 右子树的最左节点
			Node* MinR_parent = cur;  // 右子树的最左节点的 父节点：这里一定要赋值为 cur，不能赋值为 nullptr
			Node* MinRight = cur->_right; // 右子树的根

			while (MinRight->_left) {
				MinR_parent = MinRight;
				MinRight = MinRight->_left;
			}

			// 继承 cur 的位置
			cur->_key = MinRight->_key;

			
			// 删掉继承人，同时父节点接管 cur 的右孩子（为什么一定是右孩子：因为我们本代码要删除 右子树的最左节点，因此你就是最左的节点了，不可能还存在左节点）
			// 这里的问题是：Min 不知道是 MinParent的 左孩子 or 右孩子
			if (MinR_parent->_right == MinRight) {
				MinR_parent->_right = MinRight->_right;  // 可以是 空，也可以是一个节点
			}

			else MinR_parent->_left = MinRight->_right;  // 可以是 空，也可以是一个节点
			delete MinRight;
		}
	}

private:
	// 将该函数直接写成 私有
	void _InorderSearch(Node* root) {
		if (root == nullptr) {
			return;
		}
		_InorderSearch(root->_left);
		cout << root->_key << ' ';
		_InorderSearch(root->_right);
	}

	Node* _root = nullptr;
};

 

1.4 二叉搜索树的应用（Key/Value 模型的 代码）

1.4.1  两种模型

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

key ：在不在的场景

如门禁系统：人脸识别一对一

如检查当前写的文字中有没有错误单词：通过录入正确的词典，在词典中搜索对应的单词，若找不到，则说明该单词拼写错误

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

key / value：通过一个值找另一个值

如 字典

如 车库收费系统：按时收费

车辆驶入时，机器扫描 车牌作为 key，value 存为 进入时间

当你出门时，再次扫描车牌，匹配 key，通过当前时间和 value 的时间差，计算收费价格

1.4.2 <key, value> 模型的 代码

将节点改成 pair<key, value> 类型，即键值对模型

节点类模板

template<class K, class V>
struct BSTreeNode
{
	typedef BSTreeNode<K, V> Node;

	pair<K, V> _kv;
	Node* _left;
	Node* _right;

	BSTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

二叉搜索树类模板

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

public:
	// 1、查找
	bool Find(const K& val) {
		if (_root == nullptr) {
			return false;
		}

		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first > val) {
				cur = cur->_left;
			}
			else if (cur->_kv.first < val) {
				cur = cur->_right;
			}
			else return true;
		}

		return false;
	}
	// 2、插入
	Node* Insert(const pair<K, V>& data) {
		// （1）先判断节点是否存在
		if (Find(data.first)) {
			cout << "结点已存在" << '\n';
			return _root;
		}

		// （2）如果根为空，则直接插入一个节点
		if (_root == nullptr) {
			_root = new Node(data);
			return _root;
		}

		// （3）按照二叉搜索树的性质，走到合适的位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first > data.first) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < data.first) {
				parent = cur;
				cur = cur->_right;
			}
		}

		// （4）插入节点：和父节点链接上
		cur = new Node(data);
		if (parent->_kv.first > data.first) {
			parent->_left = cur;
		}
		else if (parent->_kv.first < data.first) {
			parent->_right = cur;
		}

		return _root;
	}
	// 3、中序遍历：直接就是排序了


	void InorderSearch() {
		_InorderSearch(_root);
		cout << '\n';
	}

	// 4、删除
	void Erase(const K& val) {
		// （1）先看节点是否存在
		if (!Find(val)) {
			cout << "结点不存在" << '\n';
			return;
		}

		// （2）按照搜索树的规则，找到目标节点位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (cur->_kv.first > data.first) {
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < data.first) {
				parent = cur;
				cur = cur->_right;
			}
			else break;
		}

		// （3）分情况执行删除操作：
		// 0~1个孩子：删除该节点后，让父节点指向我的孩子
		if (cur->_right == nullptr) {

			// 特殊情况：当父亲为空时，证明当前要删除的节点是根，直接删除，让根指针指向孩子
			if (parent == nullptr) {
				_root = cur->_left;
			}
			else {
				if (parent->_key > cur->_key) {
					parent->_left = cur->_left;
				}
				else if (parent->_key < cur->_key) {
					parent->_right = cur->_left;
				}
			}
			delete cur;
		}
		else if (cur->_left == nullptr) {
			if (parent == nullptr) {
				_root = cur->_right;
			}
			else {
				if (parent->_kv.first > data.first) {
					parent->_left = cur->_right;
				}
				else if (parent->_kv.first < data.first) {
					parent->_right = cur->_right;
				}
			}
			delete cur;
		}


		// 2 个孩子 及以上：替换法
		// 我们这里继承人是 ：右子树的最左节点
		else {
			// 删除 右子树的最左节点
			Node* MinR_parent = cur;  // 右子树的最左节点的 父节点：这里一定要赋值为 cur，不能赋值为 nullptr
			Node* MinRight = cur->_right; // 右子树的根

			while (MinRight->_left) {
				MinR_parent = MinRight;
				MinRight = MinRight->_left;
			}

			// 继承 cur 的位置
			cur->_kv.first = MinRight.first;

			// 删掉继承人，同时父节点接管 cur 的右孩子（为什么一定是右孩子：因为我们本代码要删除 右子树的最左节点，因此你就是最左的节点了，不可能还存在左节点）
			// 这里的问题是：Min 不知道是 MinParent的 左孩子 or 右孩子
			if (MinR_parent->_right == MinRight) {
				MinR_parent->_right = MinRight->_right;  // 可以是 空，也可以是一个节点
			}

			else MinR_parent->_left = MinRight->_right;  // 可以是 空，也可以是一个节点
			delete MinRight;
		}
	}

private:
	// 将该函数直接写成 私有
	void _InorderSearch(Node* root) {
		if (root == nullptr) {
			return;
		}
		_InorderSearch(root->_left);
		cout << root->_kv.first << " : " <<  root->_kv.second << '\n';
		_InorderSearch(root->_right);
	}

	Node* _root = nullptr;
};

使用测试代码：

void TestKV() {
	vector<pair<string, string>>v = { {"string", "字符串"}, {"apple", "苹果"}, {"banana", "香蕉"} };
	my::BSTree<string, string> tree;
	for (auto e : v) {
		tree.Insert(e);
	}
	tree.InorderSearch();
}

 

1.5 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

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

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

一种是较为 平衡的结构，一种是退化成链表的结构

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

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

问题：如果退化成单支树(像一条链表一样)，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？（即树的节点分布比较平衡）那么我们后续章节学习的 AVL树 和 红黑树 就可以上场了。

AVL树、红黑树 都是 平衡二叉树，使得 节点的分布平衡，使 搜索性能达到 O(logn)


 

时差freebright
关注
专栏目录
二叉查找树（C++）
wo_ai_luo_的博客
02-21 1091
二叉查找树是什么呢？（也叫二叉搜索树）就是字面意思，首先是一颗二叉树：一棵树，最多分两个叉。1.1 满二叉树上面那个图就是一颗二叉树，同时也是一颗满二叉树：每一个节点都有两个儿子，左儿子和右儿子。同时啊，还有完全二叉树：一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。1.2 完全二叉树1.3 普通二叉树。
【C++】二叉搜索树
fight_p的博客
11-22 1377
这是一篇万子以上的博客，本文更准确的说可以算上二叉树的进阶，详细讲解的二叉搜索树的插入，删除，查找，以及递归查找，递归删除，递归查找和构造，析构，拷贝构造，以及赋值重载，详细讲解什么是K模型，什么是KV模型，以及二叉搜索树应用场景，以及二叉搜索树性能分析
C/C++数据结构（十）—— 二叉查找树
热门推荐
Edison's 小宇宙
01-13 2万+
二叉查找树（Binary Search Tree），也称二叉排序树或二叉搜索树。
【C++学习】日积月累——二叉搜索树详解
joes_ju的博客
04-23 827
插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。对拥有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多；但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：图8 二叉搜索树的两种形态。
从C语言到C++_24(二叉搜索树)概念+完整代码实现+笔试题
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
07-06 674
从C语言到C++_24（二叉搜索树）概念+模拟实现（完整代码）+笔试选择题。下一部分：树的OJ题，然后是map和set，再然后是AVL树和红黑树。
第12章-二叉搜索树 12.1 什么是二叉搜索树 12.2 查询二叉搜索树
Toby的博客
09-06 190
第12章-二叉搜索树 12.1 什么是二叉搜索树 12.2 查询二叉搜索树（内含所有详细代码）
二叉树与二叉搜索树
数据工匠记
07-15 1701
本文将从二叉树、二叉搜索树的定义和性质入手，通过代码实现深度认识二分搜索树。 什么是二叉树？ 在我们的现实场景中，比如图书馆我们可以根据分类快速找到我们想要找到的书籍。比如我们要找一本叫做《Java编程思想》这本书，我们只需要根据理工科 —> 计算机 —>Java语言分区就可以快速找到我们想要的这本书。这样我们就不需要像数组或者链表这种结构，我们需要遍历一遍才能找到我们想要的东西。再比如，我们所使用的电脑的文件夹目录本身也是一种树的结构。 从上面的描述我们可知，树这种结构具备天然的高效性可以巧妙
【C++从0到王者】第二十九站：二叉搜索树常见题
青色_忘川的博客
09-12 160
二叉树的一些经典题
【C++】二叉搜索树的原理及实现
weixin_67596609的博客
07-31 1306
二叉搜索树(Binary Search Tree，BST)是一种常用的数据结构，本文将介绍二叉搜索树的原理与特性，并给出C++代码实现，最后对其性能进行详细的分析。
二叉搜索树（C#，C++）
10-11
在《算法导论》第三版的第12章中，作者详细介绍了二叉搜索树的概念、操作和实现。通过阅读此章，读者可以深入理解二叉搜索树的原理，并学会如何在实际编程中应用这些知识。实现过程中，需要关注代码的正确性和效率，...
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1429
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
2种解法 - 将二叉搜索树变平衡
真相很简单
03-15 1472
基于二叉树搜索中的中序排序、二分法查找两种方法实现将二叉搜索树变平衡...
二叉树最小深度
2301_80161204的博客
09-27 475
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1286
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
数据结构—排序
最新发布
2302_81258662的博客
10-03 431
在数据结构中，排序是一种将数据元素重新排列的过程，通常是为了使它们按照特定的顺序（如升序或降序）组织起来。排序在计算机科学中非常重要，下面是一些常见的数据结构排序方法和它们的特点。
904. 水果成篮
YQ20210216的博客
09-27 370
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1101
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1292
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
我要一段最优二叉搜索树C++的代码
05-18
该代码使用动态规划的思想，构建了一个二维数组`cost`，其中`cost[i][j]`表示从第`i`个关键字到第`j`个关键字构成的最优二叉搜索树的代价。在计算`cost[i][j]`时，枚举根节点的位置`r`，计算左子树和右子树的代价...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值