【数据结构高阶】红黑树

已于 2023-12-10 16:22:00 修改
阅读量1k 收藏 21
点赞数 26
分类专栏： 数据结构 文章标签： 算法 c++ 数据结构 红黑树
于 2023-12-10 08:34:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70811813/article/details/134896016
版权

目录

一、红黑树的概念

二、红黑树的性质

2.1 红黑树与AVL树的比较

三、红黑树的实现

3.1 红黑树节点的定义

3.2 数据的插入

3.2.1 红黑树的调整思路

3.2.1.1 cur为红，f为红，g为黑，u存在且为红

3.2.1.2 cur为红，f为红，g为黑，u不存在/u存在且为黑

3.2.1.2.1 g、f、cur构成一条直线

3.2.1.2.2 g、f、cur构成一条折线

3.2.2 调整部分的代码实现

3.3 红黑树的验证

3.4 测试代码

四、红黑树实现完整代码

一、红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路 径会比其他路径长出俩倍，因而是接近平衡的。

二、红黑树的性质

● 每个结点不是红色就是黑色

● 根节点是黑色的

● 如果一个节点是红色的，则它的两个孩子结点是黑色的（不允许出现连续的红色节点）

● 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点（从根节点到每个叶子节点的空孩子路径上有相同数目的黑色节点）

● 每个叶子结点的空孩子节点都是黑色的

根据上述的五条性质，我们可以发现一个红黑树中如果有N个黑色节点，则根节点到任意一个叶子节点的距离：最短为㏒⑵N，最长为2㏒⑵N

2.1 红黑树与AVL树的比较

我们来看到下面的红黑树：

对于这棵红黑树，如果将其看成一个AVL树，是需要进行旋转的，但是在红黑树结构中却不需要

所以红黑树是近似平衡的，在搜索效率上会略逊AVL树一些，但是红黑树在结构上不要求绝对的平衡，这就造成插入相同的数据红黑树翻转的次数少于AVL树

实际使用中，在经常进行增删的场景下红黑树性能比AVL树更优，并且红黑树实现比较简单，所以实际运用中红黑树更多

三、红黑树的实现

3.1 红黑树节点的定义

enum Colour
{
	RED,
	BLACK
};

template<class Key, class Val>
struct RBTreeNode
{
	RBTreeNode<Key, Val>* _left;
	RBTreeNode<Key, Val>* _right;
	RBTreeNode<Key, Val>* _parent;//多一个指针指向其父节点,方便我们的后续操作
	pair<Key, Val> _kv;
	Colour _col;//颜色标识

	RBTreeNode(const pair<Key, Val>& kv)
		:_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_kv(kv),
		_col(RED)//构造时,优先将节点的颜色置为红色
	{}
};

在这里提一下为什么要默认将节点的颜色置为红色：

在我们向红黑树中插入一个新节点时，如果将该节点置为黑色，就肯定会影响红黑树性质中的第四条：对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

例如：

我们现在在上面这棵树中，不管在哪个叶子节点的下方插入一个黑色的新增节点，从根节点到插入的节点的空孩子的路径上的黑色节点数目会变为4，而从根节点到其他叶子节点的空孩子的路径上的黑色节点数目会都为3

所以我们将新增节点的颜色置为红色就一定不会违反第四条红黑树性质，但是第三条呢？如果插入节点的父节点是红色的怎么办？

怎么办我们后面再说，反正总归比置为黑色一定会违反第四条性质好吧

3.2 数据的插入

由于红黑树也是平衡二叉搜索树的一种，我们在插入数据时也要找到合适的位置进行插入：

template<class Key, class Val>
class RBTree
{
	typedef RBTreeNode<Key, Val> Node;
public:
	bool Insert(const pair<Key,Val>& kv)
	{
		Node* cur = _root, * parent = nullptr;
		while (cur)//找到合适的位置
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				cout << "插入的值重复" << endl;
				return false;
			}
		}
		cur = new Node(kv);
		cur->_parent = parent;
		//将插入的节点连接上二叉树
		if (parent == nullptr)
		{
			_root = cur;
		}
		else if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}

private:
	Node* _root = nullptr;
};

插入到合适的位置之后，我们还要检查是否破坏了红黑树的结构（由于我们插入的是红色节点，所以只会出现两个红色节点连续的情况），如果出现了该情况，我们就要对其进行分类讨论并解决：

3.2.1 红黑树的调整思路

下面我们将出现异常情况的两个节点的那个子节点叫做cur，cur的父节点叫做father（简称f），father的父节点叫做grandfather（简称g），father的兄弟节点叫做uncle（简称u）

例如：

接下来，我们分类讨论：

3.2.1.1 cur为红，f为红，g为黑，u存在且为红

下面画出的情况表示的是抽象出的情况：A、B、C、D、E都是满足构成红黑树的子树

对于这种情况我们先将f和u节点变黑，再将g节点变红即可：

调整完后，要记得再向上检查g节点的父节点是否为红色哦~（如果g节点为整棵红黑树的根，最后要将其颜色置为黑）

3.2.1.2 cur为红，f为红，g为黑，u不存在/u存在且为黑
3.2.1.2.1 g、f、cur构成一条直线

对于这种情况：若f为g的左孩子，cur为f的左孩子，则进行右单旋：

再将f变黑，g变红：

相反， f为g的右孩子，cur为f的右孩子，则进行左单旋转：

再将f变黑，g变红：

3.2.1.2.2 g、f、cur构成一条折线

f为g的左孩子，cur为f的右孩子，则做左右双旋，旋转完后将cur节点颜色置黑、g节点颜色置红：

相反， f为g的右孩子，cur为f的左孩子，则做右左双旋，旋转完后将cur节点颜色置黑、g节点颜色置红：

对于旋转操作还不熟悉的同学可以看到这里：【数据结构高阶】AVL树

3.2.2 调整部分的代码实现

template<class Key, class Val>
class RBTree
{
	typedef RBTreeNode<Key, Val> Node;
public:

	bool Insert(const pair<Key, Val>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
	}
	Node* cur = _root, * parent = nullptr;
	while (cur)//找到合适的位置
	{
		if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			cout << "插入的值重复" << endl;
			return false;
		}
	}
	cur = new Node(kv);
	//将插入的节点连接上二叉树
	if (kv.first < parent->_kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	cur->_parent = parent;
	//开始调整
	while (parent && parent->_col == RED)//红黑树的结构出现两个连续的红色节点
	{
		Node* grandfather = parent->_parent;
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			if (uncle && uncle->_col == RED)//cur为红，p为红，g为黑，u存在且为红
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续向上更新
				cur = grandfather;
				parent = cur->_parent;
			}
			elsecur为红，p为红，g为黑，u不存在/u存在且为黑
			{
				if (cur == parent->_left)//cur在p的左边,p也在g的左边，构成一条直线
				{
					//右单旋
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else//cur在p的右边,p在g的左边，构成一条折线
				{
					//左右双旋
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;//调整完跳出
			}
		}
		else
		{
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED)//cur为红，p为红，g为黑，u存在且为红
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续向上更新
				cur = grandfather;
				parent = cur->_parent;
			}
			elsecur为红，p为红，g为黑，u不存在/u存在且为黑
			{
				if (cur == parent->_right)//cur在p的右边,p也在g的右边，构成一条直线
				{
					//左单旋
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else//cur在p的左边,p在g的右边，构成一条折线
				{
					//右左双旋
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;//调整完跳出
			}
		}
	}
	_root->_col = BLACK;//确保即便进行过调整后根节点颜色为黑
	return true;
}

private:
	void RotateL(Node* parent)//左单旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* pparent = parent->_parent;
		parent->_right = subRL;//更新parent的右节点
		if (subRL)//防止该节点为空
		{
			subRL->_parent = parent;//更新subRL的父节点
		}
		parent->_parent = subR;//更新parent的父节点
		subR->_left = parent;//subR的左子树置为parent
		subR->_parent = pparent;//更新subR的父节点
		if (pparent == nullptr)//旋转的是整棵树
		{
			_root = subR;//更新根节点
		}
		else//将旋转后的子树链接上整个二叉树
		{
			if (pparent->_left == parent)
			{
				pparent->_left = subR;
			}
			else
			{
				pparent->_right = subR;
			}
		}
	}

	void RotateR(Node* parent)//右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* pparent = parent->_parent;
		parent->_left = subLR;//更新parent的左节点
		if (subLR)//防止该节点为空
		{
			subLR->_parent = parent;//更新subLR的父节点
		}
		parent->_parent = subL;//更新parent的父节点
		subL->_right = parent;//subL的右子树置为parent
		subL->_parent = pparent;//更新subL的父节点
		if (pparent == nullptr)//旋转的是整棵树
		{
			_root = subL;//更新根节点
		}
		else//将旋转后的子树链接上整个二叉树
		{
			if (pparent->_left == parent)
			{
				pparent->_left = subL;
			}
			else
			{
				pparent->_right = subL;
			}
		}
	}

private:
	Node* _root = nullptr;
};

3.3 红黑树的验证

下面我们来写段代码来验证一课树是不是红黑树：

template<class Key, class Val>
class RBTree
{
	typedef RBTreeNode<Key, Val> Node;
public:

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点颜色是红色" << endl;
			return false;
		}

		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;
			cur = cur->_left;
		}

		// 连续红色节点
		return _Check(_root, 0, benchmark);
	}

private:
	bool _Check(Node* root, int blackNum, int benchmark)//计算每条路径上黑色节点的个数
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点的数量不相等" << endl;
				return false;
			}

			return true;
		}

		if (root->_col == BLACK)
		{
			++blackNum;
		}

		if (root->_col == RED
			&& root->_parent
			&& root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}

		return _Check(root->_left, blackNum, benchmark)
			&& _Check(root->_right, blackNum, benchmark);
	}

private:
	Node* _root = nullptr;
};

3.4 测试代码

void Test_RBTree()
{
	const size_t N = 50000;
	RBTree<int, int> t;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand() + i;
		t.Insert(make_pair(x, x));
	}
	t.InOrder();
	cout << t.IsBalance();
}

int main()
{
	Test_RBTree();
	return 0;
}

测试效果：

四、红黑树实现完整代码

#include<iostream>

using namespace std;

enum Colour
{
	RED,
	BLACK
};

template<class Key, class Val>
struct RBTreeNode
{
	RBTreeNode<Key, Val>* _left;
	RBTreeNode<Key, Val>* _right;
	RBTreeNode<Key, Val>* _parent;//多一个指针指向其父节点,方便我们的后续操作
	pair<Key, Val> _kv;
	Colour _col;//颜色标识

	RBTreeNode(const pair<Key, Val>& kv)
		:_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_kv(kv),
		_col(RED)//默认构造时,优先将节点的颜色置为红色
	{}
};

template<class Key, class Val>
class RBTree
{
	typedef RBTreeNode<Key, Val> Node;
public:

	bool Insert(const pair<Key, Val>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
	}
	Node* cur = _root, * parent = nullptr;
	while (cur)//找到合适的位置
	{
		if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			cout << "插入的值重复" << endl;
			return false;
		}
	}
	cur = new Node(kv);
	//将插入的节点连接上二叉树
	if (kv.first < parent->_kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	cur->_parent = parent;
	//开始调整
	while (parent && parent->_col == RED)//红黑树的结构出现两个连续的红色节点
	{
		Node* grandfather = parent->_parent;
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			if (uncle && uncle->_col == RED)//cur为红，p为红，g为黑，u存在且为红
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续向上更新
				cur = grandfather;
				parent = cur->_parent;
			}
			elsecur为红，p为红，g为黑，u不存在/u存在且为黑
			{
				if (cur == parent->_left)//cur在p的左边,p也在g的左边，构成一条直线
				{
					//右单旋
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else//cur在p的右边,p在g的左边，构成一条折线
				{
					//左右双旋
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;//调整完跳出
			}
		}
		else
		{
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED)//cur为红，p为红，g为黑，u存在且为红
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续向上更新
				cur = grandfather;
				parent = cur->_parent;
			}
			elsecur为红，p为红，g为黑，u不存在/u存在且为黑
			{
				if (cur == parent->_right)//cur在p的右边,p也在g的右边，构成一条直线
				{
					//左单旋
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else//cur在p的左边,p在g的右边，构成一条折线
				{
					//右左双旋
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;//调整完跳出
			}
		}
	}
	_root->_col = BLACK;//确保即便进行过调整后根节点颜色为黑
	return true;
}
	void InOrder()//中序遍历
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点颜色是红色" << endl;
			return false;
		}

		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;
			cur = cur->_left;
		}

		// 连续红色节点
		return _Check(_root, 0, benchmark);
	}

private:
	void RotateL(Node* parent)//左单旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* pparent = parent->_parent;
		parent->_right = subRL;//更新parent的右节点
		if (subRL)//防止该节点为空
		{
			subRL->_parent = parent;//更新subRL的父节点
		}
		parent->_parent = subR;//更新parent的父节点
		subR->_left = parent;//subR的左子树置为parent
		subR->_parent = pparent;//更新subR的父节点
		if (pparent == nullptr)//旋转的是整棵树
		{
			_root = subR;//更新根节点
		}
		else//将旋转后的子树链接上整个二叉树
		{
			if (pparent->_left == parent)
			{
				pparent->_left = subR;
			}
			else
			{
				pparent->_right = subR;
			}
		}
	}

	void RotateR(Node* parent)//右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* pparent = parent->_parent;
		parent->_left = subLR;//更新parent的左节点
		if (subLR)//防止该节点为空
		{
			subLR->_parent = parent;//更新subLR的父节点
		}
		parent->_parent = subL;//更新parent的父节点
		subL->_right = parent;//subL的右子树置为parent
		subL->_parent = pparent;//更新subL的父节点
		if (pparent == nullptr)//旋转的是整棵树
		{
			_root = subL;//更新根节点
		}
		else//将旋转后的子树链接上整个二叉树
		{
			if (pparent->_left == parent)
			{
				pparent->_left = subL;
			}
			else
			{
				pparent->_right = subL;
			}
		}
	}

	void _InOrder(Node* root)
	{
		if (root == NULL)//如果是空树就直接结束
		{
			return;
		}
		_InOrder(root->_left);//先递归遍历其左子树
		cout << root->_kv.first << " ";//再遍历其根节点
		_InOrder(root->_right);//最后递归遍历其右子树
	}

	bool _Check(Node* root, int blackNum, int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点的数量不相等" << endl;
				return false;
			}

			return true;
		}

		if (root->_col == BLACK)
		{
			++blackNum;
		}

		if (root->_col == RED
			&& root->_parent
			&& root->_parent->_col == RED)
		{
			cout << "存在连续的红色节点" << endl;
			return false;
		}

		return _Check(root->_left, blackNum, benchmark)
			&& _Check(root->_right, blackNum, benchmark);
	}

private:
	Node* _root = nullptr;
};
1e-12
关注
  • 26
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
手撕红黑树——C++高阶数据结构详解
qq_61500888的博客
09-06 1万+
带你一命通关红黑树 十五分钟手撕数据结构原理
高级数据结构—B树、红黑树 python实现
01-20
一棵 2t (t>=2)阶（此处阶数表示每个节点最大的孩子数量）B树是一棵平衡的 2t 路搜索树。它或者是空树，或者是满足下列性质的树： 1、根节点至少有两个子女； 2、每个非根节点所包含的关键字个数j满足：t-1<=j&lt...
【高阶数据结构】红黑树详解
m0_70980326的博客
08-17 2010
红黑树详解
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 17万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
Java高阶数据结构之红黑树
qq15035899256的博客
09-04 2831
本文是Java高阶数据结构的学习，剖析红黑树底层原理，红黑树的时间复杂度，红黑树的插入以及插入时的平衡调整。之后的学习内容将持续更新！！！
数据结构（高阶）—— 红黑树
M的博客
11-26 2844
红黑树，是一种二叉搜索树，但在每个结点上增加了一个存储位表示结点的颜色，可以使Red或Black。通过对任何一条从根到叶子的路劲上各个结点着色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而近似平衡的。对于每个结点，从该结点到其所有后代叶子结点的简单路径上，均包含相同数目的黑色结点。如果一个结点是红色的，则它的两个孩子结点是黑色的。每条路径上的黑色结点数量相同。每个结点不是红色就是黑色。此处的叶子结点指定是空结点。
数据结构之红黑树
风间琉璃の博客
04-23 888
1. 红黑树（Red Black Tree） 简称RBTree，也是一种自平衡的二叉搜索树。 1.1 性质 节点是RED或者BLACK； 根节点是BLACK； 叶子节点（外部节点，空节点）都是BLACK；它会让之前度为0或者度为1的节点添加两个null节点，变成度为2的节点； RED的子节点必须都是BLACK； RED节点的parent都是BLACK； 从根节点到叶子节点的所有路径上不能有2个连续的RED节点； 从任一节点出发到叶子节点的所有路径都包含相同数目的BLACK节点 ...
【高阶数据结构】红黑树
c565114的博客
05-25 402
所以p是红色，既然p是红色，那么g一定是黑色,否则，之前的红黑树是有问题的。如果x=1，则a,b,c,d,e代表每条路径有1个黑色结点,那么cur一定不可能是新增结点，但是cur和p是两个连续的红节点，已经违反了规则三，所以cur原本的颜色其实是黑色，它之所以变成红色是由其子树的变化影响的。这是x=0的情况，想要满足红黑树的规则三和规则四，就需要将p，u变成黑色，将g变成红色。上图是情况一和情况二合并的情况，同样的道理，也是p变黑，g变红，然后进行一次右单旋。RBTreeTest1()为测试代码。
【高阶数据结构】手撕红黑树（超详细版本）
qq_42996461的博客
01-08 2094
但行好事，莫问前程
高阶数据结构-红黑树
qq_50408340的博客
06-09 243
目录红黑树的概念红黑树的性质红黑树能自平衡靠的是什么？红黑树的插入红黑树与AVL树的比较 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 也就是说不存在两个红色节点相连 对于每个结点，从该结点到其所有
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
数据结构
高阶异构数据模糊联合聚类算法
01-14
为了更有效地分析聚簇重叠部分高阶异构数据的...实验表明，HFCC算法能够有效探测数据内部隐藏的重叠聚簇结构，并且HFCC算法聚类效果明显优于5种有代表性的硬划分算法，此外GXB指标能够有效判定高阶异构数据的聚簇数目。
LTE网络优化路测数据高阶分析.doc
11-30
LTE网络优化路测数据高阶分析.doc
算法-找出N个数组的共同元素
Python领域优质萌新创作者
06-02 482
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
LeetCode 2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3）
<font color="Pink">Tisfy的博客</font>
05-31 1060
【LetMeFly】2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3） 给你一个下标从 0 开始的二维整数矩阵 grid，大小为 n * n ，其中的值在 [1, n2] 范围内。除了 a 出现 两次，b 缺失 之外，每个整数都 恰好出现一次 。 任务是找出重复的数字a 和缺失的数字 b 。 返回一个下标从 0 开始、长度为 2 的整数数组 ans ，其中 ans[0] 等于 a ，ans[1] 等于 b 。
【算法】宵暗的妖怪
一岁就可帅的博客
05-31 450
值得注意的是，若取两段进行吞噬，反而最多只能获得6的饱食度，并不是最大的。选择[2,4,1]和[4,2,1]这两段即可。饱食度为4+2=6。选择[1,7,2]这一段即可。一个正整数，代表最终饱食度的最大值。
【LeetCode】39.组合总和
最新发布
m0_74197695的博客
06-03 350
给你一个的整数数组candidates和一个目标整数target，找出candidates中可以使数字和为目标数target的 所有，并以列表形式返回。你可以按返回这些组合。candidates中的数字可以。如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为target的不同组合数少于150个。[2,3,6,7],target =72 和 3 可以形成一组候选，2 + 2 + 3 = 7。注意 2 可以使用多次。7 也是一个候选， 7 = 7。仅有这两种组合。
算法训练营第四十五天 | LeetCode 1049 最后一块石头的重量II、LeetCode 494 目标和、LeetCode 474 一和零
qq_63149342的博客
05-31 531
继续昨天没有详细说的01背包问题往下继续说。01背包问题是将dp从一维问题升维到二维之后会遇到的一类典型问题。dp数组自然而然地是一个横坐标表示物品序号-1，纵坐标表示背包重量的二维数组。01背包由一个背包是否放该物品并比照后得到最大值，来表示表示子问题和当前问题之间关系组成递推逻辑。递推过程中由于物品数组逐渐增加，dp[i][j]在每一轮总是由dp[i-1][j]递推而来，因此可以简化为用一维滚动数组来表示。但这样第二重循环中由于从前往后遍历dp[i][0]会被存放多次，因此要。
java数据结构 红黑树
08-21
- *2* [Java高阶数据结构之红黑树](https://blog.csdn.net/qq15035899256/article/details/126678970)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

1e-12

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

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

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

打赏作者

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

抵扣说明：

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

余额充值