【C++进阶】探秘二叉搜索树

已于 2024-09-22 12:31:14 修改
阅读量1.8k 收藏 166
点赞数 186
分类专栏： C++ 文章标签： c++ 人工智能 机器学习 神经网络
于 2024-09-18 09:26:23 首次发布
小羊在奋斗
本文链接：https://blog.csdn.net/2301_78843337/article/details/142302680
版权
头像
🚀个人主页：奋斗的小羊
🚀所属专栏：C++
很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

动图描述

目录

前言

本篇文章将介绍一种功能更加强大的二叉树——二叉搜索树。
相比于普通的二叉树，二叉搜索树在很多方面都有优势，尤其是在查找数据上效率明显提高，并且通过中序遍历二叉搜索树它所存储的数据是有序的。

💥一、二叉搜索树

💥1.1 特点

二叉搜索树，是一种特殊的二叉树结构，它或为空树，或者满足以下性质：

  • 左子树性质： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值
  • 右子树性质： 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值
  • 中序遍历性质： 对二叉搜索树进行中序遍历（左根右），则遍历的结果是一个按升序排列的有序序列

在这里插入图片描述

二叉搜索树和普通二叉树的框架差不太多，需要一个节点类，再封装一个完成二叉搜索树功能的类就行。

template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* _left;
	BSTNode<K>* _right;

	//构造
	BSTNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	//查找
	bool Find(const K& key)
	{}
	
	//插入
	bool Insert(const K& key)
	{}

	//删除
	bool Erase(const K& key)
	{}

	//中序遍历
	void InOrder()
	{}
private:
	//用一个节点指针来管理二叉搜索树，缺省值为nullptr
	Node* _root = nullptr;
};

💥1.2 基本操作

💥1.2.1 插入

  • 树为空： 直接新增节点，连接到根节点上
  • 树不为空： 从根节点开始，将要插入的值与根节点的值进行比较。如果小于根节点的值，则进入左子树继续比较；如果大于根节点的值，则进入右子树继续比较。如果当前节点为空，则在该位置插入新节点。

插入数据要始终保持二叉搜索树的特点。另外二叉搜索树中的数据通常不允许重复
，所以如果要插入的数据在二叉搜索树中已经存在，则插入错误。

| 实现：

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

💥1.2.2 查找

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

| 实现：

bool 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 true;
		}
	}
	return false;
}
  • 查找过程的平均时间复杂度和最坏时间复杂度分别是O(log n)和O(n)

其中n是树中节点的数量。然而，在最坏的情况下（即树退化为链表时），时间复杂度会变为O(n)。为了保持查找效率，通常会使用平衡二叉搜索树（如AVL树、红黑树等），它们通过自平衡操作来确保树的高度保持在对数级别，在后续的文章中会介绍。

在这里插入图片描述

💥1.2.3 删除

在二叉搜索树中删除一个节点是一个稍微复杂的过程，因为它需要确保删除操作后树仍然保持二叉搜索树的属性。

  1. 查找要删除的节点： 首先，通过二叉搜索树的查找操作找到要删除的节点
  2. 处理三种情况：
  • 情况1： 如果要删除的节点是叶子节点，则直接删除该节点，并将其父节点指向它的指针设为nullptr
  • 情况2： 如果要删除的节点只有一个子节点（左子节点或右子节点），则将其父节点指向它的指针重定向到它的子节点，然后删除该节点
  • 情况3： 如果要删除的节点有两个子节点，则可以找到该节点的右子树中的最小节点（或左子树中的最大节点，但通常使用右子树中的最小节点，因为它更简单且保持了树的平衡），然后将该最小节点的值复制到要删除的节点中，并删除右子树中的那个最小节点（这实际上变成了情况1或情况2）

在这里插入图片描述

在这里插入图片描述

从上面两种不同的情况来看，找到目标节点右子树中的最小节点后，这个最小节点是它父节点的左孩子还是右孩子都是有可能的，所以在替换掉目标节点的值后，删除右子树中的最小节点之前，需要判断一下右子树中的最小节点的孩子是跟在其父节点的左还是右。

| 实现：

bool Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else//找到要删除的节点
		{
			//没有孩子或一个孩子
			if (cur->_left == nullptr)
			{
				if (_root->_key == key)
				{
					_root = _root->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else if (parent->_right == cur)
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
				cur = nullptr;
				return true;
			}
			else if (cur->_right == nullptr)
			{
				if (_root->_key == key)
				{
					_root = _root->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else if (parent->_right == cur)
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
				cur = nullptr;
				return true;
			}
			//有两个孩子
			else
			{
				//用要删除节点的右子树的最小节点代替删除节点
				parent = cur;
				Node* MinNode = cur->_right;
				while (MinNode->_left)
				{
					parent = MinNode;
					MinNode = MinNode->_left;
				}
				cur->_key = MinNode->_key;
				if (parent->_left == MinNode)
				{
					parent->_left = MinNode->_right;
				}
				else
				{
					parent->_right = MinNode->_right;
				}
				delete MinNode;
				return true;
			}
		}
	}
	return false;
}

找到要删除的节点后，删除之前有几个值得特别注意的点：

  • 要删除的节点没有孩子或只有一个孩子可以归为同一种情况处理
  • 要删除的节点可能是当前的根节点，如果是根节点要单独特殊处理，因为根节点没有父节点，和其他节点的删除处理方法不一样
  • 如果目标节点有两个孩子，则需要先找到其右子树中的最小节点，让最小节点的值替换掉目标节点的值，这个最小节点一定是叶子节点或者只有一个右孩子（两种情况可以视为同一情况处理），最小节点的右孩子要根据最小节点是其父节点的左孩子还是右孩子来确定接在哪里

💥1.2.4 中序遍历

二叉搜索树的中序遍历和普通二叉树的中序遍历是一样的。

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

但是这样写有一个问题，当我们调用中序遍历函数时，需要传一个二叉搜索树的根节点指针，而_root是BSTree类中的私有成员变量，在类外面不能使用，所以我们需要想一些办法。
既然类的私有成员变量在类外面不能使用，那我们就不在类外面使用了，可以通过函数调用在类里面间接的使用_root成员变量。

template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	//查找
	bool Find(const K& key)
	{}
	
	//插入
	bool Insert(const K& key)
	{}

	//删除
	bool Erase(const K& key)
	{}

	//中序遍历
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(const Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

💥1.2.5 二叉搜索树的简单实现

template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* _left;
	BSTNode<K>* _right;

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

template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	bool 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 true;
			}
		}
		return false;
	}
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		if (parent->_key > key)
		{
			parent->_left = new Node(key);
		}
		else
		{
			parent->_right = new Node(key);
		}
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//找到要删除的节点
			{
				//没有孩子或一个孩子
				if (cur->_left == nullptr)
				{
					if (_root->_key == key)
					{
						_root = _root->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					if (_root->_key == key)
					{
						_root = _root->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				//有两个孩子
				else
				{
					//用要删除节点的右子树的最小节点代替删除节点
					parent = cur;
					Node* MinNode = cur->_right;
					while (MinNode->_left)
					{
						parent = MinNode;
						MinNode = MinNode->_left;
					}
					cur->_key = MinNode->_key;
					if (parent->_left == MinNode)
					{
						parent->_left = MinNode->_right;
					}
					else
					{
						parent->_right = MinNode->_right;
					}
					delete MinNode;
					return true;
				}
			}
		}
		return false;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(const Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

💥1.3 默认成员函数

💥1.3.1 拷贝构造

二叉搜索树不需要我们显示去写构造，根节点指针给缺省值nullptr，用编译器默认生成的构造就可。而拷贝构造需要我们自己去实现深拷贝，因为编译器默认生成的拷贝构造是浅拷贝，不符合我们的要求。

但是，我们知道编译器生成默认构造的规则是：我们不写构造函数，编译器就会生成一个默认构造函数，而拷贝构造也是构造，我们写了拷贝构造后编译器就不再生成默认构造了，所以我们还是需要写一个默认构造，只需要形式的写一个就行。可以考虑用：BSTree() = default;。当我们使用 =default 时，意思是告诉编译器：“我知道这个成员函数可以有默认实现，请帮我生成它。”

二叉搜索树的拷贝构造用递归实现会比较简单，需要传根节点的指针，而拷贝构造函数我们知道传过来的是对象的引用，所以我们可以再包装一下，写一个拷贝函数。

//默认构造
BSTree() = default;

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

Node* copy(Node* root)
{
	if (root == nullptr)
	{
		return nullptr;
	}
	Node* NewRoot = new Node(root->_key);
	NewRoot->_left = copy(root->_left);
	NewRoot->_right = copy(root->_right);
	return NewRoot;
}

走的是后序遍历拷贝二叉树。

💥1.3.2 析构

同样的，析构函数不需要传参数，而我们想析构二叉搜索树就必须传根节点指针，那么也可以用销毁节点的函数再包装一下。

~BSTree()
{
	Destroy(_root);
	_root = nullptr;
}

void Destroy(Node* root)
{
	if (root == nullptr)
		return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

走的也是后序遍历析构二叉搜索树。

💥1.4 二叉搜索树的应用

💥1.4.1 Key模型

在K模型中，每个节点仅存储一个关键码（即Key），这个关键码用于确定节点在树中的位置，并满足二叉搜索树的性质。

  • 查找： 给定一个关键码，在二叉搜索树中查找是否存在对应的节点。查找过程从根节点开始，根据关键码与节点关键码的比较结果，决定是向左子树查找还是向右子树查找，直到找到对应的节点或确定不存在该关键码。
  • 应用场景： 可以用来拼写检查， 在文本编辑器或浏览器中，可以使用二叉搜索树的K模型来存储字典中的单词，以便快速检查用户输入的单词是否存在拼写错误。

我们上面实现的二叉搜索树就是一个简单的Key模型。

💥1.4.2 Key-Value模型

定义：

  • KV模型中的每个节点包含一个键值（Key）和一个数据值（Value），键值用于确定节点在树中的位置，数据值用于存储节点的附加信息
  • 节点的键值仍然必须满足二叉搜索树的性质，但数据值可以是任意类型或对象

应用场景：

  • 简单词典： 在英汉词典中，英文单词作为Key，其对应的中文解释作为Value。用户可以通过输入英文单词快速找到其对应的中文含义
  • 车库收费： 车进入车库时存储车牌号作为Key，进入的时间作为Value，当车从车库出来时按车牌号查找对应进入车库的时间
  • 计数器： 在需要统计元素出现次数的场景中，可以将元素作为Key，其出现的次数作为Value

这里我们以上面实现的二叉搜索树为基础，实现一个简单词典的KV模型。

template<class K, class V>
struct BSTNode
{
	K _key;
	V _value;
	BSTNode<K, V>* _left;
	BSTNode<K, V>* _right;

	BSTNode(const K& key, const V& value)
		:_key(key)
		,_value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template<class K, class V>
class BSTree
{
	typedef BSTNode<K, V> Node;
public:
	BSTree() = default;
	
	BSTree(const BSTree<K, V>& t)
	{
		_root = copy(t._root);
	}
	
	Node* copy(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* NewRoot = new Node(root->_key, root->_value);
		NewRoot->_left = copy(root->_left);
		NewRoot->_right = copy(root->_right);
		return NewRoot;
	}
	
	~BSTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
	
	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}
	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;
	}
	bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		if (parent->_key > key)
		{
			parent->_left = new Node(key, value);
		}
		else
		{
			parent->_right = new Node(key, value);
		}
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//找到要删除的节点
			{
				//没有孩子或一个孩子
				if (cur->_left == nullptr)
				{
					if (_root->_key == key)
					{
						_root = _root->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					if (_root->_key == key)
					{
						_root = _root->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					cur = nullptr;
					return true;
				}
				//有两个孩子
				else
				{
					//用要删除节点的右子树的最小节点代替删除节点
					parent = cur;
					Node* MinNode = cur->_right;
					while (MinNode->_left)
					{
						parent = MinNode;
						MinNode = MinNode->_left;
					}
					cur->_key = MinNode->_key;
					if (parent->_left == MinNode)
					{
						parent->_left = MinNode->_right;
					}
					else
					{
						parent->_right = MinNode->_right;
					}
					delete MinNode;
					return true;
				}
			}
		}
		return false;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(const Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " " << root->_value << endl;
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

请添加图片描述

💥1.4.3 性能分析

KV模型的二叉搜索树在查找、插入和删除操作上的性能通常取决于树的高度。在最坏的情况下（即树蜕化为单边树时），这些操作的时间复杂度会退化为O(n)。
可以使用平衡二叉搜索树来提高性能：

  • AVL树： 任何节点的两个子树的高度最大差别为一，这通过自平衡操作（如左旋、右旋）来维持
  • 红黑树： 一种自平衡二叉查找树，它通过每个节点附加一个表示颜色的位（红色或黑色）和通过确保树满足某些性质（如从根到叶子的最长的可能路径不多于最短的可能路径的两倍长）来保持平衡

关于平衡二叉搜索树的介绍还请在我专栏 C++ 中查找相关文章。
在平均情况下，这些操作的时间复杂度可以接近O(log n)，这使得KV模型的二叉搜索树成为一种高效的数据结构。

本篇文章的学习就到这了，如果您觉得在本文中有所收获，还请留下您的三连支持哦~

头像
_小羊_
关注
专栏目录
【C++】530 二叉搜索树的最小绝对差
ZSZ_shsf的博客
04-20 431
我们可以利用二叉搜索树的性质：中序遍历二叉搜索树可以得到一个升序的节点值序列。因此，我们只需要在中序遍历的过程中计算相邻节点值之间的差值，然后找到最小的差值即可。给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值。差值是一个正数，其数值等于两值之差的绝对值。
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
c++进阶_二叉搜索树
2401_83052144的博客
08-19 753
嗨喽大家好，时隔许久阿鑫又给大家带来了新的博客，c++进阶——二叉搜索树，下面让我们开始今天的学习吧！ c++进阶_二叉搜索树 内容安排说明 二叉搜索树实现 二叉树搜索树应用分析 二叉树进阶面试题 1. 内容安排说明 二叉树最重要的一点就是将每一个节点看成一个子树的根，对于理解会方便很多 map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构 二叉搜索树的特性了解，有助于更好的理解map和set的特性 二叉树中部分面试题稍微有点难度，在前面讲解大家不容易接受，且时间长容易忘 有些O
C++进阶：二叉搜索树
2301_81699364的博客
10-10 1006
找N左子树的值最大结点R(最右结点)或者N右子树的值最小结点R(最左结点)替代N，因为这两个结点中任意⼀个，放到N的 位置，都满足二叉搜索树的规则。• 二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，map/set/multimap/multiset系列容器底层就是二叉搜索树，其中map/set不支持插入相等值，multimap/multiset支持插入相等值。3. 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点。
【C++进阶】二叉搜索树特性 && 二叉搜索树模拟实现
2301_78611726的博客
05-02 976
我们之前在c语言部分数据结构初阶就已经讲过二叉树了，为什么那时我们不讲二叉搜索树呢？这是有原因的，这里讲二叉树进阶是因为：1.map与set特性需要先铺垫二叉搜索树的概念，理解了二叉搜索树可以更好的理解map与set2.当时用c语言讲二叉树时没有将进阶，是因为这部分较难，长时间下容易忘记。3.一些OJ题更适合用c++解决，当时用c语言会比较麻烦，需要动态开辟数组等。因此有了进阶二叉树部分，是对我们的二叉树进行的收尾总结。
LeetCode 算法：验证二叉搜索树 c++
想都是问题，做才有答案～～
06-26 1170
LeetCode 算法：验证二叉搜索树 c++
【C++】二叉搜索树
m0_62179366的博客
10-24 2084
二叉搜索树的简单应用及实现。
【 C++ 】二叉搜索树
bit_zyx的博客
09-03 1448
目录 1、二叉搜索树的概念 2、二叉搜索树的实现 ①、结点类 ②、二叉搜索树的类 2.1、默认成员函数 构造函数 拷贝构造函数 赋值运算符重载函数 析构函数 2.2、中序遍历 2.3、Insert插入函数 ............
【c++】二叉树进阶 ＞ 二叉搜索树＜K模型，KV模型＞
m0_74722801的博客
05-01 723
【c++】二叉树进阶 > 二叉搜索树
C++：二叉搜索树
2302_79054145的博客
06-06 924
关于数据结构中的树，想必都不会很陌生，今天，主要给大家一起学习搜索二叉树（BST）前面，我们掌握学习过二叉树的三种遍历方式（前序，中序，后序的递归版本），以及我们实现过顺序结构的树（堆），前面的树在储存数据方面，并没有多大的意义，而今天所说的二叉搜索树在数据存储方面就有了很大的意义。
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
c++实现在二叉检索树中删除一个结点的算法
06-23
设计一个算法程序，使得该程序从二叉检索树中删除一个结点，并仍然保持二叉检索树的特性不变 实验要求: 创建一棵二叉检索树，然后用中序遍历查找要删除的结点的后继结点
东方博宜OJ P1000-P1100题 C++ 和 Python 题解代码汇总
10-18 193
【代码】东方博宜OJ P1000-P1100题 C++ 和 Python 题解代码汇总。
汉诺塔问题和青蛙跳台阶问题（c语言）
2402_86350741的博客
10-18 268
这俩道题都是利用到了函数递归的思想，其中汉诺塔问题较难理解，青蛙跳台阶则较简单。
C语言笔记20
最新发布
2401_87749224的博客
10-18 188
给指针加1表示要让指针指向下一个变量如果指针不是指像一片连续分配的空间（如数组），这种运算就没有意义。
百度IDGC++一面-面经总结
MatsumotoChrikk
10-18 434
虚函数出现在多态、继承的情况中，在基类定义一个函数，在派生类可以重写。这也是运行时多态，虚函数就是函数前加上virtual关键字依赖虚函数表和虚表指针，只要有虚函数的类-就生成一个虚函数表。虚表指针指向这个虚函数表。查找对应的，调用函数。流量控制使用滑动窗口协议来控制流量。接收方通过广告窗口大小告诉发送方它能够接收的缓冲区大小，从而防止发送方过快地发送数据，避免接收方的缓冲区溢出。拥塞控制TCP 拥塞控制机制通过调整数据传输速率来防止网络拥塞。
C语言内存函数
L73S37的博客
10-13 458
对于重叠内存，用memmove来实现。
C++高效二叉搜索树查找算法实现探讨
资源摘要信息:"二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme" 本资源是一个关于二叉搜索树查找算法的实现的压缩包文件，文件名称为“二叉搜索树查找算法【实现】”，其内容主要涉及使用C++...
评论 302
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值