【数据结构】-----红黑树

最新推荐文章于 2024-08-29 22:06:50 发布
最新推荐文章于 2024-08-29 22:06:50 发布
阅读量1.1k 收藏 27
点赞数 25
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73470633/article/details/141125603
版权

目录

前言

一、what is it？

二、How achieve it？

 Ⅰ、结点类

Ⅱ、实现

插入

情况一：叔叔存在且为红色

 情况二：叔叔不存在或者叔叔为黑色

旋转

验证

 ①验证中序遍历

②验证是否满足红黑树的性质

Ⅲ、完整实现代码

三、AVL compare to Red BlackTree

前言

前面介绍了AVL树，它能够解决因单支树导致性能下降的问题，但是AVL树的旋转有些许的麻烦。当然，能解决因单支树导致性能下降不仅有AVL，还有一种数据结构，那就是下面介绍的红黑树。在实际运用比较多的红黑树！

一、what is it？

Ⅰ、概念

红黑树，是一种二叉搜索树，但是每个结点都有颜色，要么红色要么黑色。因此称之为红黑树。它是通过对任何一条从根到叶子的路径上结点着色方式的限制，以确保最长路径<=最短路径的2倍，因此能达到接近平衡的效果。

Ⅱ、性质

  •  根节点是黑色
  • 每个结点不是红色就是黑色
  • 一个红色结点，其两个孩子结点必须是黑色(即不能有两个连续的红色结点)
  • 对于每个结点，从该结点到其所有后代结点的路径上，黑色结点的数量必须相同(即每条路径上都存在相同数量的黑色结点)
  • 空结点(NIL)都是黑色的

 问题：红黑树怎么保证结点最长路径<=最短路径*2？

实际上根据性质的第三、四点就可以推出。

因为每条路径上黑色结点数量必须相同，那最短路径必然是全黑结点(极端情况下)，最长路径必然是一黑一红交替（不一定存在）

因此，就能保证最长路径<=最短路径*2！

注意：这里的路径是从根结点到空结点NIL算做一条。

如下：

注意上图不是一棵红黑树，因为不满足每条路径上的黑色结点数量一致这一性质。从根到6的左子树这条路径上的黑色结点数量为1，其他路径都为2！

二、How achieve it？

在给出结点类之前，需要对颜色的存储做一些处理。这里为了代码的可读性，我们对颜色的存储可以采用枚举常量。

//枚举颜色
enum Color
{
	RED,
	BLACK
};

 Ⅰ、结点类

这里和AVL类似，就是少了个平衡因子，多了个颜色。

template<class K,class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	pair<K, V> _kv;
	Color _co;
	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_co(RED)//构造新结点必须是红色，根结点除外，根节点必须黑
	{}
};

这里需要注意一个问题：新增结点一定是红色，为何？实际上就是因为第四点性质比第三点性质更加的严格，永远不能动性质四。

  • 若插入黑色结点，那必然违反性质四，即每条路径上的黑色结点数量就不一致了，每条路径都需要调整！
  • 若插入红色结点，那可能违反性质三，若其父亲是黑色，就无需调整；其父亲为红，那就变色，代价较小，所以选择插入红色结点！

注意：根结点一定是黑色的 ！

Ⅱ、实现

插入

步骤：

1.首先依旧按照二叉搜索树的规则插入。小的放在左子树，大的放在右子树

2.检测新节点插入后，红黑树的性质是否造到破坏

因为新节点默认是红色的，所以：

  • 新节点的父亲颜色如果是黑色，没有违反性质3，无需调整
  • 新节点的父亲颜色如果是红色，那就需要调整，两种情况讨论

 如果新节点的父亲是红色，说明父亲结点不是根结点，那么就存在祖先，父亲的父亲，即爷爷结点，一定是黑的，不能有两个连续的红结点嘛，所以调整的两种情况主要取决于父亲的兄弟结点，即叔叔结点的颜色。

约定：cur为当前结点(一定红)，p为父节点(红)，g为爷爷结点(黑)，u为叔叔结点

情况一：叔叔存在且为红色

 这种情况的解决方案就是：将父亲和叔叔结点变黑，爷爷结点变红

  • 若爷爷是根结点，调整完成后要变回黑色
  • 若爷爷不是根，是子树，那就需要继续向上调整。调整逻辑也是一样父亲为黑或者空就停止，红就调整。

逻辑代码

//向上调整
cur = g;
parent = cur->_parent;

抽象图

形象图(举例)

可以看到，上述抽象图cur为红色并不是因为其本身就是红色，而是因为cur的子树在调整过程中，将cur结点的颜色有黑色变成红色。

注意：对于这种情况，插在左边右边都是一样的！！变色原理一样，比AVL简单！父亲和叔叔位置互换也一样

代码实现十分简单：

Node* u = g->_right;
//情况一:叔叔存在且为红，叔叔和父亲变红，爷爷g变黑
if (u && u->_co == RED)
{
	parent->_co = u->_co = BLACK;
	g->_co = RED;

	//向上调整
	cur = g;
	parent = cur->_parent;
}
 情况二：叔叔不存在或者叔叔为黑色

这种情况就需要旋转+变色，旋转的实现和AVL完全类似。变色规则：父亲变黑，爷爷变红温

①不存在

注意：不存在时cur一定是新增，若不是，那cur和p必定有一个黑色结点，这就不满足性质4了！

②存在且为黑

核心逻辑代码：

//    g
//  p   u
// c
//右单旋，p变黑，g变红
if (cur == parent->_left)
{
		RotaRTree(g);
		parent->_co = BLACK;
		g->_co = RED;
}
//    g
//  p   u
//    c
//左右双旋，先左再右。cur就变成了p的父亲
else
{
		RotaLTree(parent);//左单旋
		RotaRTree(g);//右单旋
		cur->_co = BLACK;
		g->_co = RED;
}

这里旋转代码和AVL树一样，就是将AVL树的平衡因子去掉而已！

插入实现完整代码

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_co = BLACK;//根结点一定为黑
			return true;
		}
		//找位置插入
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		cur->_co = RED;//新增结点一定为红色
		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//插入后，开始调色
		//分情况调色
		while (parent && parent->_co == RED)//调到黑色或者空就停止
		{
			Node* g = parent->_parent;
			if (parent == g->_left)//父亲在左，叔叔在右
			{
				Node* u = g->_right;
				//情况一:叔叔存在且为红，叔叔和父亲变红，爷爷g变黑
				if (u && u->_co == RED)
				{
					parent->_co = u->_co = BLACK;
					g->_co = RED;

					//向上调整
					cur = g;
					parent = cur->_parent;
				}
				else//叔叔不存在或者存在且为黑
				{
					//    g
					//  p   u
					// c
					//右单旋，p变黑，g变红
					if (cur == parent->_left)
					{
						RotaRTree(g);
						parent->_co = BLACK;
						g->_co = RED;
					}
					//    g
					//  p   u
					//    c
					//左右双旋，先左再右。cur就变成了p的父亲
					else
					{
						RotaLTree(parent);//左单旋
						RotaRTree(g);//右单旋
						cur->_co = BLACK;
						g->_co = RED;
					}
					//不需要再调整，直接结束
					break;
				}
			}
			else//父亲在右，叔叔在左
			{
				Node* u = g->_left;
				if (u && u->_co == RED)//u存在且为红
				{
					parent->_co = u->_co = BLACK;
					g->_co = RED;

					cur = g;
					parent = cur->_parent;
				}
				else//叔叔不存在或者为黑
				{
					//    g
					//  u   p
					//        c
					//左单旋，p变黑，g变红
					if (cur == parent->_right)
					{
						parent->_co = BLACK;
						g->_co = RED;
						RotaLTree(g);
					}
					//    g
					//  u   p
					//    c
					//右左双旋，先右旋，在左旋
					else
					{
						RotaRTree(parent);//右
						RotaLTree(g);//左
						cur->_co = BLACK;
						g->_co = RED;
					}
					break;
				}
			}
		}
		_root->_co = BLACK;//始终保持根是黑色
		return true;
	}

旋转

不管是AVL树还是红黑树，二者需进行旋转形状都是一样，只是规则上的差异而各自进行特殊的处理罢了！

对于红黑树的旋转仅仅只需实现左旋和右旋即可，和AVL代码基本类似，只不过不需要控制平衡因子，情况没有AVL的复杂，十分的简单！这里直接给出实现代码，若有不解可以看看这篇文章AVL旋转！

//右旋
void RotaRTree(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	Node* pparent = parent->_parent;

	parent->_left = subLR;
	if (subLR)
		subLR->_parent = parent;
	subL->_right = parent;
	parent->_parent = subL;

	if (parent == _root)
	{
		_root = subL;
		_root->_parent = nullptr;
	}
	else
	{
		if (parent == pparent->_left)
			pparent->_left = subL;
		else
			pparent->_right = subL;
		subL->_parent = pparent;
	}
}
//左旋
void RotaLTree(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	Node* pparent = parent->_parent;

	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;
	subR->_left = parent;
	parent->_parent = subR;

	if (parent == _root)
	{
		_root = subR;
		_root->_parent = nullptr;
	}
	else
	{
		if (parent == pparent->_left)
			pparent->_left = subR;
		else
			pparent->_right = subR;
		subR->_parent = pparent;
	}
}

验证

 ①验证中序遍历

若中序遍历得到的是一个有序序列，说明为二叉搜索树。

中序遍历和二叉搜索树写法类似

public:
    void Inoder()
    {
	    _Inoder(_root);
	    cout << endl;
    }
private:
    Node *_root;//私有成员变量
	void _Inoder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inoder(root->_left);
		cout << root->kv.first<< " ";
		_Inoder(root->_right);
	}
②验证是否满足红黑树的性质

这里的难点是如何验证性质四，即如何判断每条路径上的黑色结点是否一致以及统计黑色结点数量？

统计黑色结点数

思路：实际统计黑色结点数量可以采用dfs，深度优先遍历，设置一个形参变量，一直递归到空结点为止，该形参变量代表的是从根结点到当前结点的路径上的黑色结点数量

判断每条路径上的黑色结点是否一致

思路：可以先去统计任意一条路径上的黑色结点的数量，以该路径黑色结点数量作为基准即可。若统计出有一条路径上黑色结点的数量和基准不 一致，那就出错咯！

实现代码：

	bool IsBalance()
	{
		//根为红就错误
		if (_root->_co == RED)
		{
			cout << "不符合根结点为黑这一规则" << endl;
			return false;
		}
		//先以一条路径为标志位，每条路径上的黑色结点的数和该标志位相比，不一样就不满足规则四
		int refnum = 0;//基准位
		Node* cur = _root;
		while (cur)
		{
			if (cur->_co == BLACK)
				refnum++;
			cur = cur->_left;//以最左路径上的黑色结点为基准
		}
		return _IsBalance(_root, 0, refnum);
	}
private:
	Node* _root = nullptr;
	bool _IsBalance(Node* root, int curblacknum, const int refnum)
	{
		if (root == nullptr)
		{
			if (curblacknum != refnum)
			{
				cout << "存在黑色结点不同的路径" << endl;
				return false;
			}
			return true;
		}
		if (root->_co == RED && root->_parent->_co == RED)
		{
			cout << "存在连续两个红色结点" << endl;
			return false;
		}
        //碰到黑色结点就++
		if (root->_co == BLACK)
		{
			++curblacknum;
		}

		return _IsBalance(root->_left, curblacknum, refnum) && _IsBalance(root->_right, curblacknum, refnum);
	}

Ⅲ、完整实现代码

#include <iostream>
using namespace std;

//枚举颜色
enum Color
{
	RED,
	BLACK
};
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	pair<K, V> _kv;
	Color _co;
	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _co(RED)
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_co = BLACK;//根结点一定为黑
			return true;
		}
		//找位置插入
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		cur->_co = RED;//新增结点一定为红色
		if (kv.first > parent->_kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//插入后，开始调色
		//分情况调色
		while (parent && parent->_co == RED)//调到黑色或者空就停止
		{
			Node* g = parent->_parent;
			if (parent == g->_left)//父亲在左，叔叔在右
			{
				Node* u = g->_right;
				//情况一:叔叔存在且为红，叔叔和父亲变红，爷爷g变黑
				if (u && u->_co == RED)
				{
					parent->_co = u->_co = BLACK;
					g->_co = RED;

					//向上调整
					cur = g;
					parent = cur->_parent;
				}
				else//叔叔不存在或者存在且为黑
				{
					//    g
					//  p   u
					// c
					//右单旋，p变黑，g变红
					if (cur == parent->_left)
					{
						RotaRTree(g);
						parent->_co = BLACK;
						g->_co = RED;
					}
					//    g
					//  p   u
					//    c
					//左右双旋，先左再右。cur就变成了p的父亲
					else
					{
						RotaLTree(parent);//左单旋
						RotaRTree(g);//右单旋
						cur->_co = BLACK;
						g->_co = RED;
					}
					//不需要再调整，直接结束
					break;
				}
			}
			else//父亲在右，叔叔在左
			{
				Node* u = g->_left;
				if (u && u->_co == RED)//u存在且为红
				{
					parent->_co = u->_co = BLACK;
					g->_co = RED;

					cur = g;
					parent = cur->_parent;
				}
				else//叔叔不存在或者为黑
				{
					//    g
					//  u   p
					//        c
					//左单旋，p变黑，g变红
					if (cur == parent->_right)
					{
						parent->_co = BLACK;
						g->_co = RED;
						RotaLTree(g);
					}
					//    g
					//  u   p
					//    c
					//右左双旋，先右旋，在左旋
					else
					{
						RotaRTree(parent);//右
						RotaLTree(g);//左
						cur->_co = BLACK;
						g->_co = RED;
					}
					break;
				}
			}
		}
		_root->_co = BLACK;//始终保持根是黑色
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		//根为红就错误
		if (_root->_co == RED)
		{
			cout << "不符合根结点为黑这一规则" << endl;
			return false;
		}
		//先以一条路径为标志位，每条路径上的黑色结点的数和该标志位相比，不一样就不满足规则四
		int refnum = 0;//基准位
		Node* cur = _root;
		while (cur)
		{
			if (cur->_co == BLACK)
				refnum++;
			cur = cur->_left;
		}
		return _IsBalance(_root, 0, refnum);
	}
private:
	Node* _root = nullptr;
	bool _IsBalance(Node* root, int curblacknum, const int refnum)
	{
		if (root == nullptr)
		{
			if (curblacknum != refnum)
			{
				cout << "存在黑色结点不同的路径" << endl;
				return false;
			}
			return true;
		}
		if (root->_co == RED && root->_parent->_co == RED)
		{
			cout << "存在连续两个红色结点" << endl;
			return false;
		}
		if (root->_co == BLACK)
		{
			++curblacknum;
		}

		return _IsBalance(root->_left, curblacknum, refnum) && _IsBalance(root->_right, curblacknum, refnum);
	}
	//右旋
	void RotaRTree(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* pparent = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parent == pparent->_left)
				pparent->_left = subL;
			else
				pparent->_right = subL;
			subL->_parent = pparent;
		}
	}
	//左旋
	void RotaLTree(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* pparent = parent->_parent;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (parent == pparent->_left)
				pparent->_left = subR;
			else
				pparent->_right = subR;
			subR->_parent = pparent;
		}
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

};

void TestRBTree()
{
	RBTree<int, int> r;
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 ,8, 3, 1, 10, 6, 4, 7, 14, 13 };
	for (auto b : a)
	{
		r.Insert({ b,b });
	}
	r.InOrder();
	if (r.IsBalance())
	{
		std::cout << "十分的平衡" << std::endl;
	}
	else
	{
		std::cout << "歪了" << std::endl;
	}
}

三、AVL compare to Red BlackTree

红黑树和AVL树都是高效的平衡二叉树，都能够解决二叉搜索树的单支树的问题，增删改查的时间复杂度都是高度次，即O(logN)，但是二者的控制平衡的规则不同

  • 红黑树只需保证最长路径<=最短路径*2即可
  • AVL要严格控制平衡因子，即左右子树的高度差的绝对值不超过1

相对而言，红黑树降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优 ，而且红黑树实现起来简单，看代码就能看出来了，所以实际中运用红黑树更多！

红黑树一般多用于：

  • C++STL库---map/set，mutil_map/mutil_set的底层实现(后续有文章)
  • Java库
  • Linux内核
  • 其他一些库

 好了，兄弟们今天的内容就分享到这，如果对你有帮助，欢迎点赞+关注！你的支持永远是我的动力！

suri ..
关注
  • 25
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-红黑树.zip
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
数据结构-红黑树（全篇）
10-17
红黑树代码资源
数据结构-----红黑树的删除操作
m0_73633088的博客
10-17 1059
只有流过血的手指，才能弹出世间的绝唱。—— 泰戈尔今天我们接着学习红黑树，前面学习了红黑树的插入操作，那这次就学习红黑树的删除操作，相较于红黑树的插入操作，红黑树的删除操作更加复杂，但是别急，下面我会非常详细的去讨论这个过程，以及提供完整的代码，好了，开始上正文。相关链接数据结构-----红黑树简介_Gretel Tade的博客-CSDN博客数据结构-----红黑树的插入_Gretel Tade的博客-CSDN博客），这个是一个红黑树模拟器的网址，你们可以去进行红黑树插入删除遍历等操作，可以自己试试看。
数据结构-----红黑树的插入
m0_73633088的博客
10-16 779
在数据结构当中，旋转操作是一种很常见的操作，可能去实现数据结构平衡或者其他相关特性的要求，同样的的AVL树和红黑树里边也是要进行旋转操作的，通过旋转来满足平衡的特性。旋转分两种：左旋（Left Rotation）和右旋（Right Rotation）
数据结构 - 红黑树
2302_79539362的博客
07-26 1202
数据结构 - 红黑树
数据结构-红黑树
m0_61433144的博客
08-18 1136
红黑树也是一种二叉排序树，在红黑树中每个结点存储着对应的颜色(红色或者黑色)，由于AVL树的高度平衡是因为非常频繁地调用旋转来保存自身平衡的，代价较大。所以在AVL树的基础上进一步放宽条件，引入红黑树，即红黑树的最长路径不会比最短路径长两倍。......
408-数据结构-红黑树
qq_49400568的博客
07-27 1905
408红黑树定义重点，插入了解。删除考的概率几乎为0，因为太难了。 红黑树与二叉排序树类似，都需要满足左子树<根结点<右子树。 他们俩的查找添加与删除都在O(logn)数量级。 但是区别在于，二叉排序树在进行插入与删除操作时候，及其有可能导致平衡条件被破坏，此时就需要进行平衡二叉树，因为平衡条件算较为苛刻的条件。在大量的插入删除操作用平衡二叉树就显得比较吃力。 红黑树在进行插入以及删除时候破坏“平衡”可能性较低，就不需要进行“平衡”。因为红黑树条件较没有那么苛刻。 红黑树的逻辑结构：说白了就是树
红黑树-基于Java实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由计算机科学家...总的来说，红黑树是数据结构中的重要组成部分，尤其在需要高效存储和检索大量有序数据的场合。通过理解和掌握红黑树的原理和实现，能提升编程能力，优化程序性能。
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
- 转换操作：在插入和删除过程中，可能需要将红黑树转换成其他数据结构，如AVL树，以满足特定需求。 在实际应用中，红黑树广泛用于各种场景，如C++标准库中的STL map和set，它们底层就是基于红黑树实现的。红黑树的...
数据结构之单向、双线链表
2301_78503818的博客
08-28 497
首先我们先定义链表节点的类型，以及里面包含的数据和存储下一个节点地址的指针，然后通过定义变量，使用malloc函数来申请一个头结点的空间，而后进行赋值操作即可完成对头结点的创建。链表大体可以分成有头链表（有头节点）和无头链表，今天主要记录一下单向链表和双线链表的一些基本操作。3.单向链表的遍历，寻找，删除，更改。6.链表的复杂操作（读者可酌情观看）链表空间的释放（链表的销毁）2.头插法插入链表节点。
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1230
数据结构-时间、空间复杂度-详解
【Java & 数据结构】HashMap和HashSet介绍
qq_42150700的博客
08-29 501
Map 和 Set 是 Java 集合框架中的两个接口, 其分别对应着两种不同的搜索模型. 其中 一个是纯 key 模型, 另一个则是 key-value 模型.纯 key 模型就类似于一个集合, 里面装载着一些元素, 这些元素只包含其本身. 例如我有一个冰箱, 里面装着各式各样的饮料, 那么此时这个冰箱就可以看作是一个饮料的集合, 里面装载着饮料. 此时如果我要在里面找饮料, 找的就是饮料本身.
【数据结构】-----哈希
m0_73470633的博客
08-29 459
一文看懂哈希结构！
Redis八种数据结构简介
最新发布
m0_67496588的博客
08-29 592
Redis八种数据结构
【数据结构-二维前缀和】【含空间优化】力扣3070. 元素和小于等于 k 的子矩阵的数目
sjsjs11的博客
08-29 141
col_sum[j]在遍历行的时候，也会依次计算该列的元素和，要计算前缀和s，实际上就是目前该列的元素和逐列累加，当发现s大于k的时候，那么就停止该行接下来的前缀和，继续计算下一行第一列开始的前缀和，继续遍历行的某个位置的前缀和。这种方法就是传统的前缀和做法，在这道题中，如果group[i][j]小于k，则继续遍历，然后count增加，如果group[i][j]大于k，说明不需要继续遍历这一行接下来列的前缀和了，直接开始计算新一行每一列的前缀和。返回包含 grid 左上角元素、元素和小于或等于 k 的。
数据结构-线性表
zhoupenghui168的博客
08-29 583
好了,线性表相关数据结构就基本上差不多了, 从上面可知,线性表分为顺序表,链表(单向,双向),栈,队列等,他们存储的是单值情况,那么如果要存储多值情况,如:key-value情况,怎么办呢,这里就需要使用符号表了
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 995
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
数据结构(Java)实现：栈和队列
li_wj6的博客
08-29 776
一篇文章，带你通过Java学习数据结构中的栈和队列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值