【二叉树进阶】二叉搜索树

已于 2024-09-17 15:47:28 修改
阅读量1.4k 收藏 23
点赞数 35
分类专栏： C++ 文章标签： 算法 数据结构 c++ c c语言
于 2024-09-16 20:37:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_75924820/article/details/142304420
版权

目录

1. 二叉搜索树概念

2. 二叉搜索树的实现

2.1 创建二叉搜索树节点

2.2 创建实现二叉搜索树

2.3 二叉搜索树的查找

2.4 二叉搜索树的插入

2.5 二叉搜索树的删除

2.6 中序遍历

2.7 完整代码加测试

3. 二叉搜索树的应用

3.1 K模型：

3.2 KV模型：

4. 二叉搜索树的性能分析

1. 二叉搜索树概念

二叉搜索树（BST，Binary Search Tree）：可以是一颗空树，满足以下性质：

  • 根节点的值大于左子树上所有节点的值，小于右子树上所有节点的值。
  • 它的左子树和右子树也分别为二叉搜索树。

它的中序遍历是有序的：0 1 2 3 4 5 6 7 8 9 ，所以也称为二叉排序树或二叉查找树。

2. 二叉搜索树的实现

int a[ ] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };

2.1 创建二叉搜索树节点

template<class K>
struct BSTreeNode
{
	BSTreeNode* _left;
	BSTreeNode* _right;
	K _key;
	//初始化节点
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

2.2 创建实现二叉搜索树

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
    //操作实现
    //查找
    bool Find(const K& key) { }
    //插入
    void Insert(const K& key) { }
    //删除
    bool Erase() { }
    //中序遍历
    void InOrder() { }
private:
    Node* _root = nullptr;
}

2.3 二叉搜索树的查找

a、从根开始查找，比根大往右边查找，比根小往左边查找。

b、最多查找高度次，走到空，还没找到，则要查找的值不存在。

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

2.4 二叉搜索树的插入

a、如果树为空，新增节点，赋值给_root指针。

b、按搜索二叉树性质查找插入位置，插入节点。

c、要插入的位置一定为为空的位置，所以要插入，还要找到要插入位置的父节点，让父节点指向新插入的节点。

bool Insert(const K& key)
{
	//如果树为空，新增节点
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _root;
	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);
	if (key < parent->_key)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	return true;
}

2.5 二叉搜索树的删除

a、先判断要删除的元素是否存在，不存在，返回false。

b、若存在，则分为以下情况:

  1. 要删除的节点（叶子节点）左右子树为空
  2. 要删除的节点左子树为空或右子树为空
  3. 要删除的节点左子树右子树都不为空

实际操作起来，情况1和情况2能合并到一起实现，只有两种情况：

  • 要删除的节点的左子树或右子树为空：直接删除-----让父亲指向要删除节点右子树（左子树），再直接删除该节点。

如果要删除的该节点为根，则直接让它的右子树（左子树）赋值给_root让它成为新根即可。

  • 要删除的节点的左右子树都不为空：替换法删除----在它的右子树中找到最小值（最左节点）或在左子树中找到最大值（最右节点），将它的值与要删除节点的值替换，这时就转换为该节点的删除问题。

右子树最左节点的左子树一定为空，左子树最右节点的右子树一定为空，这就转换为第一种情况的删除了。

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		//查找
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			//找到了 删除
			else
			{
				//1.要删除节点的左子树为空或者右子树为空
				if (cur->_left == 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 (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
				}
				//要删除的左右子树都不为空
				else
				{
					//这里找到是右子树的最左值
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;//要替换的节点
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}
					//替换法交换
					cur->_key = rightMin->_key;
					//转换成删除rightMin
					if (rightMin == rightMinParent->_right)
					{
						//rightMin的左子树一定为空
						rightMinParent->_right = rightMin->_right;
					}
					else
					{
						rightMinParent->_left = rightMin->_right;
					}
					delete rightMin;
				}
				//这里我们去找左子树的最大值
				//else
				//{
				//	Node* leftMaxParent = cur;
				//	Node* leftMax = cur->_left;
				//	while (leftMax->_right)
				//	{
				//		leftMaxParent = leftMax;
				//		leftMax = leftMax->_right;
				//	}
				//	//替换法删除
				//	cur->_key = leftMax->_key;
				//	//转换为删除leftMax
				//	if (leftMax == leftMaxParent->_left)
				//	{
				//		leftMaxParent->_left = leftMax->_left;
				//	}
				//	else
				//	{
				//		leftMaxParent->_right = leftMax->_left;
				//	}
				//	delete leftMax;
				//}
				return true;
			}
		}
		return false;
	}

2.6 中序遍历

中序遍历：按照左子树 根 右子树的方式迭代遍历二叉树。

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

总之，我们在实现二叉搜索树的时候一定要考虑多种情况，每种情况也要多找几个节点进行分析。

2.7 完整代码加测试

BSTree.hpp:

//创建二叉树节点
template<class K>
struct BSTreeNode
{
	BSTreeNode* _left;
	BSTreeNode* _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 = nullptr;
		Node* cur = _root;
		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);
		if (key < parent->_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;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		//查找
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			//找到了 删除
			else
			{
				//1.要删除节点的左子树为空或者右子树为空
				if (cur->_left == 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 (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
				}
				//要删除的左右子树都不为空
				else
				{
					//这里找到是右子树的最左值
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;//要替换的节点
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}
					//替换法交换
					cur->_key = rightMin->_key;
					//转换成删除rightMin
					if (rightMin == rightMinParent->_right)
					{
						//rightMin的左子树一定为空
						rightMinParent->_right = rightMin->_right;
					}
					else
					{
						rightMinParent->_left = rightMin->_right;
					}
					delete rightMin;
				}
				//这里我们去找左子树的最大值
				//else
				//{
				//	Node* leftMaxParent = cur;
				//	Node* leftMax = cur->_left;
				//	while (leftMax->_right)
				//	{
				//		leftMaxParent = leftMax;
				//		leftMax = leftMax->_right;
				//	}
				//	//替换法删除
				//	cur->_key = leftMax->_key;
				//	//转换为删除leftMax
				//	if (leftMax == leftMaxParent->_left)
				//	{
				//		leftMaxParent->_left = leftMax->_left;
				//	}
				//	else
				//	{
				//		leftMaxParent->_right = leftMax->_left;
				//	}
				//	delete leftMax;
				//}
				return true;
			}
		}
		return false;
	}
	bool Find(const K& key)
	{
		if (_root == nullptr)
		{
			return false;
		}
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_left)
			{
				cur = cur->_left;
			}
			else if (key > cur->_right)
			{
				cur = cur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}
private:
	Node* _root = nullptr;
};
void TestBSTree()
{
	BSTree<int> t;
	int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
	for (auto e : a)
	{
		t.Insert(e);
	}
	for (auto e : a)
	{
		t.Erase(e);
		t.InOrder();
	}
}

Test.cpp:

#include"BSTree.hpp"
int main()
{
	TestBSTree();
	return 0;
}

运行结果：

3. 二叉搜索树的应用

3.1 K模型

K模型只有Key作为关键码，结构中只需要存储Key即可，关键码就是要搜索的值。

用途：判断Key在不在。

比如：给一个单词，判断该单词是否正确：

  • 以词库中所有单词集合中的每个单词作为key，构建一颗二叉搜索树
  • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

其实就是上面我们实现的二叉搜索树的查找。这里不在重复实现了。

3.2 KV模型

每一个关键码Key，都有与子对应的Value，即<Key,Value>的键值对。

用途：通过Key找对应的Value。

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

也很简单，其实就是让二叉搜索树中的节点多存一个值Value，查找、插入、删除等操作依旧是按照key去实现的。

改造二叉搜索树为KV结构模型：

template<class K,class V>
struct BSTreeNode
{
	BSTreeNode<K,V>* _left;
	BSTreeNode<K,V>* _right;
	K _key;
	V _value;//多存一个值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)
	{ }
	void _InOrder(Node* root)
	{ }
	void InOrder()
	{ }
	bool Erase(const K& key)
	{ }
	Node* Find(const K& key)//返回节点的指针，这里不再实现
	{ }
private:
	Node* _root = nullptr;
};

应用测试1：输入英文查找对应的中文

void TestBSTree()
{
	BSTree<string, string> dict;
	dict.Insert("string", "字符串");
	dict.Insert("tree", "树");
	dict.Insert("int", "整型");
	dict.Insert("search", "查找");
	dict.Insert("insert", "插入");
	string str;
	while (cin >> str)
	{
		BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret == nullptr)
		{
			cout << "词库中无此单词" << endl;
		}
		cout << ret->_value << endl;
	}
}

结果：

应用测试2：查找水果出现的次数

void TestBSTree()
{
	string arr[] = { "苹果","香蕉","西瓜","西瓜","香梨","西瓜" ,"苹果" ,"西瓜" ,"西瓜" ,"香蕉" ,"苹果" };
	BSTree<string, int> t;
	int i = 0;
	for (auto e : arr)
	{
		BSTreeNode<string, int>* ret = t.Find(e);
		//ret为空说明要查找的是第一次出现
		if (ret == nullptr)
		{
			t.Insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	t.InOrder();
}

结果：

3.3 二叉搜索树的修改

二叉搜索树中Key是不能被修改的。

如果是KV模型的搜索树，可以修改Value，但是不能修Key

4. 二叉搜索树的性能分析

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

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二
叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同（无序、接近有序），可能得到不同结构的二叉搜索树：

  • 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log2N（以2为底N的对数）。
  • 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N。
如果为单支树，二叉搜索树的性能就没有了，那么这种情况就要用到AVL树和红黑树了，后续再讲解。

郭源潮1
关注
专栏目录
【二叉树进阶】红黑树（Red Black Tree） - 平衡二叉搜索树
codewinter的博客
06-21 3360
红黑树，是一种平衡二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。AVL树和红黑树：红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于AVL树，使得红黑树整体性能略优于AVL树，不然map和set底层怎么会用红黑树呢，包括很多语言的库里面都用了红黑树。如果发明AVL树的人是天才的话，那么发明红
C++进阶 二叉搜索树的讲解
Mike的博客
09-15 1329
讲解二叉树的内容。
二叉树进阶：二叉搜索树
2301_80468112的博客
07-17 614
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:树的雏形： 1.2 二叉搜索树操作 int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};1. 二叉搜索树的查找a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。b、最多查找高度次，走到到空，还没找到，这个值不存在。 2. 二叉搜索树的插入插入的具体过程如下：a. 树为空，则直接新增节点，赋值给root指针b. 树不空，按二叉搜索树性质查找插入位置，插入新节点 1. 二叉
二叉树进阶--二叉搜索树
weixin_72068014的博客
02-13 815
二叉搜索树的学习以及相关题目的解决
二叉树进阶之二叉搜索树
逃离枷锁，冲向天空！
02-27 948
当删除节点既有左孩子又有右孩子的时候我们面对的问题就是他被删除后他的两个孩子节点怎么办，这个时候我们就有两种解决的办法，一个是找一个左子树的最大节点，另一种办法就是找右子树的最小节点来替代这个被删除的节点的值，这种情况不同于上面两种情况，我们叫做替代删除。其实插入的节点到最终都是一个叶子节点，所以二叉搜索树的插入还是很简单的，就比如我要插入0和16，最终都是成为这棵树的新的叶子节点。下图中打x叉的就不是二叉搜索树，因为第三层的5小于他的父节点10，打勾的就是二叉搜索树，它满足了二叉搜索树的所有条件。
二叉树进阶——二叉搜索树
czt230610的博客
09-13 273
我们发现，删除某一个数据分为三类：没有孩子的删除（1、7），一个孩子的删除（6、14），这两种类型的删除比较简单，释放空间然后让其父节点指向其左右孩子构成新的链接即可（一会我们将用代码实现）。接下来我们写一下插入函数（insert），先点一下思路：我们要利用二叉搜索树的性质，我们先用插入的数据与根去比，比根小向左走，比根大向右走，这样它最多比较树的高度次即可完成插入（当然，为了不让数据冗余，如果这棵数中已经有和插入的数据一样大的，那么就选择不插入，所以，我们也应完善它的查找功能）。一、什么是二叉搜索树。
二叉树进阶——二叉搜索树（c＋＋实现）
qq_58761784的博客
10-10 800
在数据结构部分我们学习了一部分二叉树的知识，包括二叉树实现堆及堆排序，使用递归实现链式二叉树，其中设计二叉树的应用场景很少，并不是二叉树的实用性弱，而是我们目前掌握的知识不足以使用二叉树来应付大多数应用场景。我们学习基础二叉树的知识很大一部分原因是为了学习进阶二叉树打基础，学习需要循序渐进，二叉树的学习也不是能短时间就掌握的，这一期开始我们就要开始重点介绍一些实用性强的二叉树，有了之前学习二叉树的基础，我们接下来的学习也会更加得心应手。
【C++进阶：二叉树进阶】二叉搜索树的操作和key模型、key/value模型的实现 | 二叉搜索树的应用 | 二叉搜索树的性能分析
DanceBit的博客
08-27 1555
从这里开始 C++ 的语法就告一段落了。二叉树在前面的数据结构和算法初阶中就讲过，本文取名为二叉树进阶是因为：我们之前说过，普通二叉树单纯的存储数据价值不大，因为仅仅是单纯的存储数据，你不如去使用顺序表和链表这样友善的多。它一定要套一种应用场景，二叉树的其中一个重要的应用场景就是我们本文中要学习的二叉搜索树。二叉搜索树又称搜索二叉树或二叉排序树 (如果你对下图的二叉搜索树中序遍历，你会发现它是有序并且升序的)，我们当前学习的搜索二叉树一般是不允许修改的，不过下面我们会学习搜索二叉树的 key_value 模
C++进阶 二叉搜索树
fen_0108的博客
07-31 1590
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二 叉搜索树的深度的函数，即结点越深，则比较次数越多。此为删除的是根节点且根节点左子树为空的情况，直接将右子树的地址赋值给root，让他作为根节点即可，当然根节点右子树为空也是同样操作，如果删除的节点是父节点的左子树，比父亲小，根据性质，左子树所有值都比根小，所以删除节点的右子树也比父节点小，所以成立。如果删除的节点是父节点的右子树，比父亲大，他的右子树比他本身还要大，所以接上后成立。
C++初阶学习————二叉树进阶（二叉搜索树）
hxMGE的博客
11-29 471
入门学习
单链表+顺序表+队列+栈+排序+图+二叉树+二叉排序树.zip
06-23
8. **二叉排序树**：二叉排序树（也称为二叉搜索树）是一种特殊的二叉树，其中每个节点的值大于其左子树中的所有节点值，小于其右子树中的所有节点值。`二叉排序树.txt`可能包含构建、搜索、插入和删除节点的高效...
【二叉树进阶】二叉搜索树的结构、实现及应用
codewinter的博客
06-15 1505
普通的二叉树单纯用来存储数据意义不大，还不如用数组和链表。普通数组和链表，面对一些需要频繁查找、插入、删除的场景，也很麻烦。所以这里引入了二叉搜索树。二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：二叉搜索树的结构特点带来的好处：定义二叉搜索树节点类模板： 定义二叉搜索树类模板： 2.2 默认成员函数的实现 2.2.1 构造函数 2.2.2 拷贝构造函数（要弄懂） 2.2.3 赋值运算符重载（要弄懂） 2.2.4 析构函数 三、二叉搜索树的相关接口实现 3.1 二叉搜索树
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2737
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
Javascript算法——双指针法移除元素、数组去重、比较含退格字符、有序数组平方
最新发布
警警的博客
10-17 289
暴力求解法（两层for循环）,length单词拼写错误❌二次嵌套for的length设置。return位置❌ ,核心基础。双指针法（一层for循环）
二叉树系列 10/11
2301_78191305的博客
10-11 431
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
【算法】深入了解 CRC 校验码的计算过程
qq_20623849的博客
10-16 440
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 252
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
力扣10.13
qq_40052678的博客
10-13 390
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【鸟类识别系统】Python+卷积神经网络算法+人工智能+深度学习+ResNet50算法+计算机课设项目
子午的博客
10-12 1022
鸟类识别系统。本系统采用Python作为主要开发语言，通过使用加利福利亚大学开源的200种鸟类图像作为数据集。使用TensorFlow搭建ResNet50卷积神经网络算法模型，然后进行模型的迭代训练，得到一个识别精度较高的模型，然后在保存为本地的H5格式文件。在使用Django开发Web网页端操作界面，实现用户上传一张鸟类图像，识别其名称。本项目通过人工智能技术实现对鸟类图像的自动识别，满足用户在日常生活中快速、准确地识别鸟类的需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值