天翔龙闪

真c++ 从二叉树到红黑树（6）之红黑树RedBlack

此文章为从二叉树到红黑树系列文章的第六节，主要介绍介绍红黑树，相信，有了之前BST，AVL和B树的铺垫，你会很快地理解红黑树。但红黑树的情况也十分复杂，因此，推荐分两天来看红黑树。一天看插入，一天看删除。

文章目录

一、所有文章链接~（点击右边波浪线可以返回目录）

理解红黑树之前，需要了解的知识点：~

二、引入红黑树~
三、红黑树的性质~

1.红黑树的外部节点~
2.红黑树的性质~

红黑树性质解读~

3.红黑树的适度平衡~
4.红黑树与B树（2,4）树的关系（提升变换）~

提升变换的四种组合~

四、红黑树类~

（一）定义变量和接口~

1.利用已有的变量~
2.需要的接口~
3.重要辅助函数~

（1）重写高度更新算法~
（2）双红，双黑缺陷~

4.类内辅助静态函数~
5.RedBlack.h~

（二）高度更新~

高度更新代码~

（三）红黑树的插入代码~
（四）双红修复~

1) u为黑色~

a) LL型~
b) RR型~
c) LR型~
d) RL型~

2) u为红色~

a) LL型~
b) RR型~
c) LR型~
d) RL型~

3) 求当前节点的叔叔代码~
4) 双红修复代码递归版~
5) 双红修复代码迭代版~
6) 双红修复的复杂度~

（五）红黑树的删除~

1.再探removeAt语义~

（1）removeAt的第一种和第二种情况~
（2）removeAt的第三种情况~
（3）结论~
（4）removeAt其他细节~

2.红黑树的删除~

（1）删除情况分析~
（2）删除代码~
（3）判断黑高度是否平衡代码~

（六）双黑缺陷~

（1）s为黑，其至少有一个红孩子~
（2）s为黑，s的两个孩子为黑，p为红~
（3）s为黑，s的两个孩子为黑，p为黑~
（4）s为红，s的两个孩子必然为黑，p必然为黑~
（5）双黑修复递归版~
（6）双黑修复迭代版~
（7）双黑修复复杂度~

五、完整RedBlack.h~
六、红黑树测试~

1.插入测试代码~
2.插入测试图示~
3.删除测试代码~
4.删除测试图示~

七、结语~

一、所有文章链接~（点击右边波浪线可以返回目录）

在阅读本文前，强烈建议你看下前面的文章的目录、前言以及基本介绍，否则你无法理解后面的内容。链接如下：

基本二叉树节点，通用函数二叉树节点
基本二叉树类的定义和实现二叉树基类
BST（二叉搜索树的实现） BST
AVL（二叉平衡搜索树的实现）AVL
B树的实现（如果你只想了解B树，可以跳过所有章节，直接看B树，B树的理解是红黑树的基础）B树
红黑树的实现 RedBlack

理解红黑树之前，需要了解的知识点：~

在本系列文章第三部分BST中的删除的基本原理
在本系列文章第四部分AVL中的connect34和rotateAt的基本原理
在本系列文章第五部分B树中的插入和删除，上溢和下溢的基本原理
如果你还不了解，那么看接下来的内容，你可能会有点吃力。

二、引入红黑树~

AVL树尽管可以保证最坏情况下的单次操作速度，但需在节点中嵌入平衡因子等标识；更重要的是，删除操作之后的重平衡可能需做多达⌊log2n⌋次旋转，从而频繁地导致全树整体拓扑结构的大幅度变化。

红黑树即是针对后一不足的改进。通过为节点指定颜色，并巧妙地动态调整，红黑树可保证：在每次插入或删除操作之后的重平衡过程中，全树拓扑结构的更新仅涉及常数个节点。

三、红黑树的性质~

1.红黑树的外部节点~

一棵树，所有叶节点都有空孩子指针，因此，为了方便理解，可以将这些空孩子指针全部视为外部节点。即假想地加入外部节点（实际并没有加入），使得树中任何节点都可以视为有左右孩子。

下面是一颗红黑树

若按1中给这颗树增加外部节点，就可以得到

2.红黑树的性质~

提示：如果你看红黑树的算法，感到某些地方不好理解时，不妨来看看红黑树的性质，你就会明白算法为什么要这么设计。

由红、黑两色节点组成的二叉搜索树若满足以下条件，即为红黑树

(1) 树根始终为黑色
(2) 外部节点均为黑色（NULL LEAF）（假想，实际不存在）
(3) 其余节点若为红色，则其孩子节点必为黑色，反之，其父亲也必然为黑色。
(4) 从根节点到任一外部节点的沿途，黑节点的数目相等（黑深度相等）

红黑树性质解读~

由条件（1）（2）可知，红节点必然为内部节点。
由条件（3）可知红节点的孩子和父亲必然为黑色。即树中任何一条通路中绝对不可能有相邻的红节点。
由以上两个分析可知，在从根节点通往任一节点的沿途，黑节点都不少于红节点。
从根节点到任意节点所经的黑节点数目称为该节点的黑深度（由上往下）。（根节点黑深度为0）。由条件（4）可知，所有外部节点的黑深度必然相等。
从外部节点到内部任意节点，所经的黑节点的个数的最大值，称之为这个内部节点的黑高度（由下往上）。因此，外部节点的黑高度为0，根节点的黑高度等于外部节点的黑深度。
由以上可以得知，任意一个节点，其左右子树的黑高度都必然相等。

3.红黑树的适度平衡~

由2中的红黑树的性质解读的第三条，可以得知

在从根节点通往任一节点的沿途，黑节点都不少于红节点。

而一棵树，就是由红节点和黑节点组成，这样就代表，黑节点的数目，至少比全树所有节点的数目的一半大。而这一点，恰恰就是红黑树适度平衡的条件。

TB为黑高度（H），T为全树的高度（h）。

更严格的有log2(n + 1) <= h <=2∙log2(n + 1)（证明略）

尽管红黑树不能如完全树那样可做到理想平衡，也不如AVL树那样可做到较严格的适度平衡，但其高度仍控制在最小高度的两倍以内，从渐进的角度看仍是O(logn)，依然保证了适度平衡—这正是红黑树可高效率支持各种操作的基础。

4.红黑树与B树（2,4）树的关系（提升变换）~

往下看之前，建议你理解一下B树的上溢和下溢。不懂的就看看本系列文章的第五部分，我对B树进行了详解。

在后面就可以得知，经适当转换之后，红黑树和（2,4）树相互等价！
具体地，自顶而下逐层考查红黑树各节点。每遇到一个红节点，都将对应的子树整体提升一层，从而与其父节点（必黑）水平对齐，二者之间的联边则相应地调整为横向。

由红黑树的性质（3）可得，对于有红孩子的黑节点而言，提升过程中，所涉及的节点至多不超过3个（可能为2个，当只有一个红孩子时），因为其最多只有两个红孩子，而对应的红孩子必然只有黑孙子，没有红孙子。

因此由变换之后的结果可以观察到，可以把变换之后的3个节点（或2个节点）看做一个整体，其恰好可以构成4阶B树（3个关键码）中的一个节点。因此，变换之后，每一颗红黑树都对应一颗（2,4）树。

提升变换的四种组合~

1、通往黑节点的边对红黑树的黑高度有贡献，以实线表示，保留下来。
2、通往红节点的边对红黑树的黑高度没有贡献，以虚线表示，不予保留。

下图中，上方是红黑树，下方是对应的B树。

从上图可以看出，对应的（2,4）B树。每个节点有且仅有一个黑色的关键码，同时红色的关键码不超过两个，若某个节点果真包含两个红关键码，则黑关键码的位置必然居中。

四、红黑树类~

（一）定义变量和接口~

1.利用已有的变量~

在第一部分定义二叉树节点的时候，我们定义了一个

RBColor _color;//红黑树专用

这个枚举类，主要是用于表示红黑树的颜色信息。具体为

namespace {
	enum class RBColor { RED, BLACK };
}

并且同样，我们会用到在BST定义的_hot节点

BinNodePtr _hot;//"命中节点"的"父亲"

2.需要的接口~

由于在BST中，我们已经定义了查找search算法，因此，不需要给RedBlack重新写查找算法，只需要对插入和删除算法进行重写既可（并且在后面可以发现，其插入和删除的本质，跟BST和AVL一模一样！）。并且在BinTree中，我们也定义了遍历算法，因此，也沿用即可。

在树中插入一个节点insert
在树中删除一个节点remove

3.重要辅助函数~

（1）重写高度更新算法~

由于红黑树的高度的表示方式为黑高度，所以其高度更新的算法也需要进行重写

更新高度updateHeight

（2）双红，双黑缺陷~

这两个辅助函数，正是红黑树得以保持平衡的最主要原因。在接下来介绍插入时，会解释双红缺陷，在介绍删除时，会解释双黑缺陷。

solveDoubleRed解决双红缺陷
solveDoubleBlack解决双黑缺陷

4.类内辅助静态函数~

为了加快算法执行的效率，和方便理解，在红黑树类内定义了4个静态内联函数。前两个很好理解，后面两个在介绍插入和删除算法时会进行解释。

IsBlack//判黑//当然x为空，也为黑色
IsRed//非黑即红

IsBlackHeightBalanced//判断是否需要更新黑高度
uncle//获取当前节点的叔叔

5.RedBlack.h~

template<typename T=int>
class RedBlack :public BST<T> {
protected:
	using BinNodePtr = BinNode<T>*;

protected:
	void solveDoubleRed(BinNode<T>* x);//双红修正
	void solveDoubleBlack(BinNode<T>* replacer);//双黑修正
	constexpr int updateHeight(BinNode<T>* x)const override;//更新高度
	
public:
	BinNode<T>* insert(const T& data)override;//插入重写
	bool remove(const T& data)override;//删除重写
	/*查找沿用BST的查找*/
	/*遍历沿用BinTree的遍历*/

protected:
	static constexpr bool IsBlack(const BinNodePtr& x) {//判黑//当然x为空，也为黑色
		return ((!x) || (RBColor::BLACK == x->_color));
	}

	static constexpr bool IsRed(const BinNodePtr& x) {//非黑即红
		return !IsBlack(x);
	}

	static constexpr bool IsBlackHeightBalanced(const BinNodePtr& x) {//判断是否需要更新黑高度
		bool is_L_C_Equal = (stature(x->_lchild) == stature(x->_rchild));
		int rbHeight = (IsRed(x) ? stature(x->_lchild) : stature(x->_lchild) + 1);//对于rbHeight的计算而言，取左孩子还是右孩子，均一样
		bool is_Height_Equal = (x->_height == rbHeight);
		return is_L_C_Equal && is_Height_Equal;//只要有一个为假，即为假
												//所以只要左孩子和右孩子高度相等，或者x没有高度变化，就黑高度平衡											
	}

	static inline BinNodePtr uncle(const BinNodePtr& x) {/*获取x的叔叔*/
		return IsLChild(x->_parent) ? x->_parent->_parent->_rchild : x->_parent->_parent->_lchild;
	}

};//class RedBlack

（二）高度更新~

下面是我们在本系列文章第一部分定义的获取当前节点高度的全局静态函数。并且我们规定当没有节点时，高度为-1，当有一个节点时，高度为0（见第一部分关于树的语义规定中树的高度的定义）。此规定依然适用于红黑树，也就是说，哪怕红黑树此时只有一个根节点（必然为黑），其高度为0而不是1。
此规定，对于后序红黑树的平衡不造成任何影响，但若读者要获取红黑树的高度的话，就需要明白此时的黑高度，比实际的黑高度少1。

template<typename BinNodePtr>
static constexpr int stature(const BinNodePtr& x) {//获取高度
    return x ? x->_height : -1;//空指针高度为-1
}

高度更新代码~

template<typename T>
constexpr int RedBlack<T>::updateHeight(BinNode<T>* x) const//由于stature视空节点高度为-1，所以height会比黑高度少一
{
	x->_height = std::max(stature(x->_lchild), stature(x->_rchild));//孩子一般黑高度相等，除非出现双黑
	return IsBlack(x) ? x->_height++ : x->_height;//若当前节点为黑，则计入黑高度
}

由于重写了更新高度函数，所以此时x的高度，为黑高度。
要更新红黑树的高度（即黑高度），只有当：

（1）左右孩子黑高度不相等。
（2）x为黑节点时，其高度要加1。
（3）x为红节点时，其高度不需要额外更新。

（三）红黑树的插入代码~

红黑树的插入算法，与BST，AVL的基本插入方式一模一样，唯一不同的是后续要进行双红修复。

先用BST的search确定不存在这个节点，并且更新_hot的位置,并以_hot为父亲，创建一个新节点。并将其黑高度更新为-1，以及染色成红色（我们默认新加入的节点均为红色节点，除非新加的是根节点）。

由BinNode节点的构造函数，默认新节点为红色。

template<typename T>
BinNode<T>* RedBlack<T>::insert(const T& data)
{
	BinNode<T>*& x = this->search(data);//沿用BST的查找//并更新_hot//用引用接收
	if (x)//如果节点存在，则返回
		return x;
	x = new BinNode<T>(data, this->_hot, nullptr, nullptr, -1);//设定黑高度-1，并默认节点为红色
	this->_size++;
	solveDoubleRed(x);//双红修正//x此时必为红
	return x;
}

（四）双红修复~

因新节点的引入，而导致父子节点同为红色的此类情况，称作“双红”（double red）。每引入一个关键码，双红修正函数都可能迭代地调用多次。在此过程中，当前节点x的兄弟及两个孩子（初始时都是外部节点），必然均为黑色。

因为x的父亲为红色，所以其只可能有黑孩子，所以x若有兄弟，则必为黑色。
由于x为新节点，其外部节点为空，即默认均为黑孩子。

将x的父亲与祖父分别记作p和g。既然此前的红黑树合法，故作为红节点p的父亲，g必然存在且为黑色。

此时的g，必然存在，否则作为树根的节点p不可能为红色；并且g作为红色节点p的父亲，其必然为黑色的

在下面的过程中，仅仅有x p g这三个节点还不够，因此，还需要一个额外的节点，即p的兄弟（x的叔叔）u。

以下，视节点u的颜色不同（若u不存在，其颜色也视为黑，这符合之前外部节点的颜色定义），分两类情况分别处置。

1) u为黑色~

u为黑色时，具体来说，对应四种结构.

此时x的兄弟和两个孩子的黑高度必然都与u的黑高度相等。

a) LL型~

在原来的树中，插入了新节点x。构成下图所示的结构。

此时，可以利用B树来理解，不妨先将红黑树，经过提升变换，提升为对应的（2,4）B树。

从B树的结构可以看出，其不满足先前提升变换的四种情况中的任何一种。
因此，要想其满足提升变换的四种情况，最简单的做法，就是将p与g互换颜色，让对应的（2,4）B树变成下图所示形式

再将对应的（2,4）B树还原成红黑树，即为

即原来的 x 变成 a，原来的 p 变成 b ，原来的 g 变成 c 。
但也注意到，相应的孩子节点的位置也发生了新的变化。

因此，如何做到这样的变化呢？此时不妨想想在本系列文章第三部分定义的AVL中的connect34算法，其对应的形状也是这样的形状

没错，只要我们将对应的x p g按照connect34的形式进行重构，就可以达到目的。

b) RR型~

同LL型一样处理，不多赘述。

c) LR型~

在原来的树中，插入了新节点x。构成下图所示的结构。此时仍然满足x的兄弟和两个孩子的黑高度必然都与u的黑高度相等这个条件。

此时，同样可以利用B树来理解，不妨先将红黑树，经过提升变换，提升为对应的（2,4）B树。

情况总是惊人的相似，可以发现，现在的形状的调整方式，不正是同LL型的调整方式一模一样么？只是x p g的相对位置有所变化。因此，也是需要进行connect34重构。

d) RL型~

同LR型一样处理，不多赘述。

2) u为红色~

u为红色时，具体来说，对应四种结构

此时，u的左、右孩子均为黑色（可能为空），其黑高度必与x的兄弟以及两个孩子相等。

a) LL型~

在原来的树中，插入了新节点x。构成下图所示的结构。

此时，同样可以利用B树来理解，不妨先将红黑树，经过提升变换，提升为对应的（2,4）B树。

在介绍LR型的时候，会展示怎么处理这种情况。

b) RR型~

同LL型一样处理，不多赘述。

c) LR型~

在原来的树中，插入了新节点x。构成下图所示的结构。此时仍然满足x的兄弟和两个孩子的黑高度必然都与u的黑高度相等这个条件。

此时，同样可以利用B树来理解，不妨先将红黑树，经过提升变换，提升为对应的（2,4）B树。

可以看到，提升变换之后，其这个大节点的关键码数目，均必然为4个，超出了4阶B树的个数限制（4阶B树的一个大节点的关键码数最多只能有3个）。所以可以仿照B树的情况，进行一次上溢。同时进行染色以满足原来B树提升变换后的四种形态。（问号节点中必然有一个为黑，按照红黑树的提升变换，只有当g染成红时才可以进行提升变换）

从红黑树的角度来看，对比没有变换之前


从宏观上来看，对于红黑树而言，只需要将p u的颜色由红色变成黑色，并且若g不为根节点的话，就将g染色成红色。当然，若g此时就是根节点，其强制变成黑色。

同样，由于g变成了红色，所以还需要继续判断g的父亲是否是红色，因此要继续进行双红修复。最坏的情况，可能要持续到根节点。（由x到g，上升了两层）。累计最多迭代logn次。

d) RL型~

同LR型一样处理，不多赘述。

3) 求当前节点的叔叔代码~

static inline BinNodePtr uncle(const BinNodePtr& x) {/*获取x的叔叔*/
	return IsLChild(x->_parent) ? x->_parent->_parent->_rchild : x->_parent->_parent->_lchild;
}

4) 双红修复代码递归版~

注意要是已经递归到树根，则树根强制转黑

	template<typename T>
	void RedBlack<T>::solveDoubleRed(BinNode<T>* x)
	{
		if (IsRoot(x)) {//若已递归到树根，则树根转黑，整树高度也随之递增
			this->_root->_color = RBColor::BLACK;
			this->_root->_height++;
			return;
		}//否则x的父亲必然存在

		BinNode<T>* p = x->_parent;//x的父亲
		if (IsBlack(p))//如果x的父亲为黑，则终止调整
			return;//否则x的父亲必然为红，则

		BinNode<T>* g = p->_parent;//x的祖父必然存在，并且，其颜色必然为黑色
		BinNode<T>* u = uncle(x);//x的叔叔，可能为空节点

		if (IsBlack(u)) {//当u为黑色时（u为空时，也为黑色）

			if (IsLChild(x) == IsLChild(p))
				p->_color = RBColor::BLACK;
			else
				x->_color = RBColor::BLACK;
			g->_color = RBColor::RED;
			/// 以上虽保证总共两次染色，但因增加了判断而得不偿失
			/// 在旋转后将根置黑、孩子置红，虽需三次染色但效率更高

			BinNode<T>*& newNode = this->FromParentTo(g);//先记录祖父的父亲的孩子指针
			newNode = this->rotateAt(x);
			/*对x进行调整，调整之后的返回值必然为调整之后的局部子树的树根位置，此时，只需要
			将此树根作为原来祖父的父亲的孩子既可，当然，高度也随之更新*/
			
			return;//只要旋转了一次，就调整完整，退出循环
		}
		else {//若u为红色
			p->_color = RBColor::BLACK;//父亲此时必然为红色，将其转黑
			p->_height++;

			u->_color = RBColor::BLACK;//叔叔此时必然为红色，将其转黑
			u->_height++;

			if (!IsRoot(g))//如果祖父不为根节点，就转红
				g->_color = RBColor::RED;

			solveDoubleRed(g);//递归用
		}
	}

5) 双红修复代码迭代版~

为了方便理解，我将递归的部分变成了注释，并未进行删除，方便读者比对，迭代版中，不仅将尾递归转换成了迭代，也将染色的效率进行了优化。

template<typename T>
void RedBlack<T>::solveDoubleRed(BinNode<T>* x)
{
	while (true) {
		if (IsRoot(x)) {//若已迭代到树根，则树根转黑，整树高度也随之递增
			this->_root->_color = RBColor::BLACK;
			this->_root->_height++;
			return;
		}//否则x的父亲必然存在

		BinNode<T>* p = x->_parent;//x的父亲
		if (IsBlack(p))//如果x的父亲为黑，则终止调整
			return;//否则x的父亲必然为红，则

		BinNode<T>* g = p->_parent;//x的祖父必然存在，并且，其颜色必然为黑色
		BinNode<T>* u = uncle(x);//x的叔叔，可能为空节点

		if (IsBlack(u)) {//当u为黑色时（u为空时，也为黑色）

			//if (IsLChild(x) == IsLChild(p))
			//	p->_color = RBColor::BLACK;
			//else
			//	x->_color = RBColor::BLACK;
			//g->_color = RBColor::RED;
			/// 以上虽保证总共两次染色，但因增加了判断而得不偿失
			/// 在旋转后将根置黑、孩子置红，虽需三次染色但效率更高

			BinNode<T>*& newNode = this->FromParentTo(g);//先记录祖父的父亲的孩子指针
			newNode = this->rotateAt(x);
			/*对x进行调整，调整之后的返回值必然为调整之后的局部子树的树根位置，此时，只需要
			将此树根作为原来祖父的父亲的孩子既可，当然，高度也随之更新*/

			//重染色/*能省去之前的判断*/
			newNode->_color = RBColor::BLACK;
			newNode->_lchild->_color = RBColor::RED;
			newNode->_rchild->_color = RBColor::RED;
			return;//只要旋转了一次，就调整完整，退出循环
		}
		else {//若u为红色
			p->_color = RBColor::BLACK;//父亲此时必然为红色，将其转黑
			p->_height++;

			u->_color = RBColor::BLACK;//叔叔此时必然为红色，将其转黑
			u->_height++;

			if (!IsRoot(g))//如果祖父不为根节点，就转红
				g->_color = RBColor::RED;

			//solveDoubleRed(g);//递归用
			x = g;//将x变成其祖父，进入迭代循环。
		}
	}
}

6) 双红修复的复杂度~

邓老师已经用一个流程图和一个表格，帮助我们详细地分析了双红修复算法的复杂度。其中zag，zig是左右旋（也就是我们的connect34重构）

RR代表双红

可见，对于u为黑的情况，只需做一轮修正；u为红的情况虽有可能需要反复修正，但由于修正位置的高度会严格单调上升，故总共也不过O(logn)轮。另外从该表也可看出，每一轮修正只涉及到常数次的节点旋转或染色操作。

因此，节点插入之后的双红修正，累计耗时不会超过O(logn)。即便计入此前的关键码查找以及节点接入等操作，红黑树的每次节点插入操作，都可在O(logn)时间内完成。

（五）红黑树的删除~

红黑树的删除算法，本质同BST，AVL的删除。在删除节点方面。两者没什么区别，唯一的区别即高度的更新方式不同。因此，可以调用在BST中设定的给AVL的删除接口removeAt全局函数。

现在我们继续来看看removeAt函数的作用

定义在BST中的removeAt函数

template<typename T>//适用于AVL Splay,RedBlack等，必须这么设计，才能做到完美删除，且保持BST的性质
static BinNode<T>* removeAt(BinNode<T>*& x, BinNode<T>*& hot) {//这里x必须用引用，才不会使指针乱指
	using BinNodePtr = BinNode<T>*;								

	//记录x的地址里面保存的值，若删除temp里面的值，即删除x里面的值，但x的本身地址不会影响temp，反之亦然。
	BinNodePtr temp = x;

	//替代被删除节点的接替者，一般为被删除节点的左孩子或者右孩子，而不是x的左孩子或者右孩子
	BinNodePtr replacer = nullptr;

	if (!HasLChild(x)) {//如果x没有左孩子，或者x左右孩子均无，则将x的右孩子作为x，并将接替者设为x的右孩子
		x = x->_rchild;
		replacer = x;
	}
	else if (!HasRChild(x)) {//如果x没有右孩子，则将x的左孩子作为x，并将接替者设为x的左孩子
		x = x->_lchild;
		replacer = x;
	}
	else {
		temp = temp->succ();//取得中序遍历的后继//这个后继必将没有左孩子
		std::swap(x->_data, temp->_data);//交换对应的值
		if (temp->_parent == x) {//如果后继的父亲是原来的x，后继必然为x的右孩子
			replacer = temp->_rchild; //就将后继的右孩子作为父亲的右孩子
			temp->_parent->_rchild = replacer;
		}
		else {//如果后继的父亲不是原来的x，后继必然为某一节点的左孩子
			replacer = temp->_rchild;
			temp->_parent->_lchild=replacer;//就将后继的右孩子作为这个节点左孩子
		}
	}
	//hot即被删除节点的父亲。而temp正是要删除的节点。
	hot = temp->_parent;
						
	if (replacer)//若replacer存在，则必须将其父指针指向hot。不然如同x->_rchild的父亲指向的还是原来的
		replacer->_parent = hot;
	
	//释放原来x所指的堆区的数据，或者x的后继的堆区的数据
	release(temp->_data);
	release(temp);

	return replacer;
}

1.再探removeAt语义~

从removeAt的语义（3种删除的情况）来看，删除的节点可能是x，可能是x的后继。

（1）removeAt的第一种和第二种情况~

从removeAt的第一种和第二种情况来看，删除的节点必然为x。即表明此时的x要么没有孩子，要么只有一个孩子。即此时x必然有一个空孩子（也一定是黑孩子）。

下面图的情况，全部是用来删除节点x 删除节点1，实际删除的也是1（removeAt的第一种情况）

删除节点1，实际删除的也是1（removeAt的第一种情况）

删除节点1，实际删除的也是1（removeAt的第二种情况）

可以看到，此时x必然有一个空孩子（也一定是黑孩子）。

（2）removeAt的第三种情况~

从removeAt的第三种情况来看，删除的节点为x的后继，由后继的定义可知，这个后继必然没有左孩子（这种后继的情况，必然属于在本系列文章第一节谈到的求后继的第一种情况，并且我用红字标明了这种后继一定没有左孩子），不然不可能删这个后继。

删除节点10，实际删除的是15（removeAt的第三种情况）

可以看到，15必然没有左孩子，其左孩子为空节点（黑节点）。

因此，x的后继必然有一个空孩子（也是黑孩子）。

（3）结论~

综合（1）（2）可以得到一个非常重要的结论：

无论被删除的是x还是x的后继，被删除节点，都必然有一个空孩子（也是黑孩子）。

（4）removeAt其他细节~

1. 在removeAt函数中，交换x与后继的值时，也只是交换了它们的data值，并非交换了它们的所有东西，因此，x的原来的颜色，和其后继的颜色均没变。

std::swap(x->_data, temp->_data);//交换对应的值

2.在删除完成后_hot节点也指向了被删除节点的父亲节点。

//hot即被删除节点的父亲。而temp正是要删除的节点。
hot = temp->_parent;

3.removeAt的返回值是replacer，即被删除节点的接替者。

BinNodePtr replacer//替代被删除节点的接替者，一般为被删除节点的左孩子或者右孩子，可能为空

2.红黑树的删除~

（1）删除情况分析~

对于删除时节点（可能是x被删，也可能是其后继被删）的颜色进行分类讨论的话，无外乎就五种情况。

（1）被删除后，原树没有任何节点，删除即可完成。

（2）被删除的是根节点，只需要将其接替者replacer染成黑色，并更新高度既可，删除完成。

（3）实际被删除节点x为红色，其必然只有黑孩子和黑父亲，并且w必然为空（根据removeAt的结论），此时只需将r接替x的位置既可。（当然r也可能为空）

x代表被删除节点，w代表必然为空的那个节点，r代表replacer也就是被删除节点的接替者。p为x的父亲

此时，毫无例外，删除x对原树的黑高度肯定没有影响，因此直接删除既可。删除完成后，即可结束。

（4）实际被删除节点为黑色，w同样也为空（根据removeAt的结论）。若r为红色，此时，只需要在r接替x的位置之后，将r转成黑色，那么原树的黑高度也必然恢复，删除完成。

（5）实际被删除节点为黑色，w同样也为空（根据removeAt的结论）。若r为黑，即出现双黑情况，则需要做进一步的调整变换。（当然，这种情况，也必然包含了r为空孩子的情况）

（2）删除代码~

template<typename T>
bool RedBlack<T>::remove(const T& data)
{
	BinNode<T>*& x = this->search(data);//找有没有这个节点，如果没有，则返回false,记住用引用
	if (!x)
		return false;
	BinNode<T>* replacer = removeAt(x, this->_hot);//调用在BST定义的全局静态函数removeAt,返回被删除节点的接替者，同时更新_hot

	--this->_size;//更新规模
	//1.如果这个被删除节点是树中唯一节点，则直接返回
	if (this->_size==0) {
		this->_root = nullptr;//将根节点置空
		return true;
	}

	//2.如果被删除节点为根节点，则_hot必然为空//但如果进行到此，说明此时_root必然不为空，不然上一就会退出
	if (this->_hot == nullptr) {
		this->_root->_color = RBColor::BLACK;//就将此时的根节点直接染成黑色
		updateHeight(this->_root);//并更新根节点的高度
		return true;
	}//如果进行到此，说明被删除节点必然存在，并且不为根节点。_hot也必然存在

	/*3.如果_hot的黑高度不变则返回*/
	/*此时也必然包括了被删除节点为红色节点的情况，若为红色，则删除对高度没有影响*/
	/*当然，也包括了双黑的可能情况*/
	if (IsBlackHeightBalanced(this->_hot))
		return true;

	/*4.如果_hot的黑高度变了，说明被删除节点必然为黑色*/
	if (IsRed(replacer)) {//就看x的接替者是不是红色，如果是红色，将其染成黑色，就必然可以使树的高度恢复。
		replacer->_color = RBColor::BLACK;
		replacer->_height++;
		return true;
	}

	/*5.如果进行到此，就必然说明被删除节点和replacer均为黑色节点（replacer可能为空），此时，就需要进行双黑缺陷判断*/
	/*要进行到这里的条件即为被删除节点的父亲的黑高度变了，并且被删除节点的接替者也为黑色时。*/
	solveDoubleBlack(replacer);
	return true;
}

（3）判断黑高度是否平衡代码~

在红黑树的删除过程中，我们需要判断黑高度是否平衡。

static constexpr bool IsBlackHeightBalanced(const BinNodePtr& x) {//判断是否需要更新黑高度
	bool is_L_C_Equal = (stature(x->_lchild) == stature(x->_rchild));
	int rbHeight = (IsRed(x) ? stature(x->_lchild) : stature(x->_lchild) + 1);//对于rbHeight的计算而言，取左孩子还是右孩子，均一样
	bool is_Height_Equal = (x->_height == rbHeight);
	return is_L_C_Equal && is_Height_Equal;//只要有一个为假，即为假
											//所以只要左孩子和右孩子高度相等，或者x没有高度变化，就黑高度平衡											
}

（六）双黑缺陷~

若被删除节点和其接替者（可能为空）均为黑。则显然，为了保持红黑树的平衡性，原来被删除节点必然有一个非空兄弟（其孩子可能均为空），不然黑高度就无法维持。

不妨将被删除节点x的兄弟记作s。被删除节点的父亲记作p。无论哪一个，颜色都不确定。

因此，分s和p的颜色情况，分四种情况来讨论。

（1）s为黑，其至少有一个红孩子~

先以s为p的左孩子，x为p的右孩子来处理（对称情况处理方式完全相同）
左为红黑树，右为对应的B树

此时删除了节点x，类似于B树的处理方式，由于其左兄弟有一个多余的关键码，所以要从其左兄弟借一个关键码。调整后为（当然，调整之后，要满足提升变换的四种情况，因此需要重染色）

左侧是B树，右侧是红黑树

并且图（b）的结构也是令人十分熟悉，没错，也就是connect34重构。
因此，从红黑树的角度来看，此过程等效于对节点t，s，p进行3+4重构。

位置调整好后，再进行重染色，即把t，p染成黑色，s继续沿用之前p的颜色。并且在此过程中，r的颜色没有发生变化。

显然，调整完之后，红黑树的高度得以复原。因此调整完毕。

（2）s为黑，s的两个孩子为黑，p为红~

先以s为p的左孩子，x为p的右孩子来处理（对称情况处理方式完全相同）
左为红黑树，右为对应的B树

（p的位置不可能是中间，只可能是左边或者右边）

此时的B树，被删除的x无法从s中借关键码，所以只有父亲下溢。为保持红黑树的性质不变，因此下溢后，只需将s和p的颜色互换，就能保持性质。

（p的左右节点中有且仅有一个黑色关键码，因此p下溢，不会造成对应B树结构的破坏）

因此，从红黑树的角度来看，只需将s与p的颜色进行互换，就能使红黑树的高度得到复原。

（3）s为黑，s的两个孩子为黑，p为黑~

先以s为p的左孩子，x为p的右孩子来处理（对称情况处理方式完全相同）
左为红黑树，右为对应的B树

由于删除了x，s也没有足够的关键码，因此，只能p下溢。并且由于p所在层次，必然只有p一个关键码，因此，p的下溢，必将导致上层下溢。

下溢之后，将s置为红色，对应的红黑树为

因此，从红黑树的角度来看，即把s由黑转红。

由于p是下溢过来的，所以需要做进一步的检查，此时等效于原树中p的黑父亲刚删除，因此可以看做又是一次双黑缺陷。所以需要再次做迭代循环。

这也是双黑修正过程中，需要再次迭代的唯一可能。（可能进入情况1 2 3 4中任何一种）。

（4）s为红，s的两个孩子必然为黑，p必然为黑~

先以s为p的左孩子，x为p的右孩子来处理（对称情况处理方式完全相同）
左为红黑树，右为对应的B树

从B树的角度来看，此时可以将p下溢，并将s’转红，s转黑，但这样会导致以s’为根的子树的高度变化，并且由于x被删除，以x为根的子树的高度必然也下降。所以，如果仅仅这么调整，会造成两颗子树的高度减少，使得情况变得更加复杂。

而先辈们已经有了很好的解决方式。

即先将s与p互换颜色，得到左图所示的B树，将其转换为红黑树为右图所示。

从红黑树的角度来看，这一转换对应于以节点p为轴做一次旋转，并交换p与s的颜色。

可以发现，经过上述处理后，双黑缺陷依然存在，而且缺陷位置的高度也未上升。但此次变换并非没有意义，仔细观察图b可以发现，被删除节点x有了一个新兄弟s’,并且s’必然为黑。

并且，调整之后，可以发现a与b所示的红黑树，完全等价。

再仔细观察，不难发现，此时x p s’对应的情况，不正是之前双黑修复过程中出现的情况（1）与（2）么

所以，只需要将调整之后的红黑树，再进行一次双黑修复，就必然可以修复高度。

（5）双黑修复递归版~

template<typename T>
void RedBlack<T>::solveDoubleBlack(BinNode<T>* replacer)
{
		BinNode<T>* p = replacer ? replacer->_parent : this->_hot;
		if (p == nullptr)
			return;//如果replacer的父亲为空，则返回/*由下面的情况来分析，无论哪种情况，递归的这个节点，必然为黑色*/所以不需要考虑将根节点强转黑色

		BinNode<T>* sibling = (replacer == p->_lchild) ? p->_rchild : p->_lchild;//原来x的兄弟，也就是replacer此时的兄弟
		if (IsBlack(sibling)) {
			BinNode<T>* s_Red_child = nullptr;//sibling的红孩子（若左右孩子皆为红，则左者优先；皆黑时为nullptr）
			if (IsRed(sibling->_rchild))//需要判断sibling是不是空指针
				s_Red_child = sibling->_rchild;//右孩子
			if (IsRed(sibling->_lchild))
				s_Red_child = sibling->_lchild;//左孩子
/*1.第一种情况，黑s有红孩子*/
			if (s_Red_child != nullptr) {//如果sibling有红孩子
				RBColor oldColor = p->_color;//备份父亲的颜色

				/*接下来对s的红孩子，s以及p进行3+4重构*/
				/*根据3+4重构后的定义，其返回的节点为根节点指针，这个根节点的名字不妨设为newNode*/
				BinNode<T>*& newNode = this->FromParentTo(p);//首先记录父亲的 父亲的孩子的指针
				newNode = this->rotateAt(s_Red_child);//3+4重构
				
				//对3+4重构后的节点进行重染色
				if (HasLChild(newNode)) {
					newNode->_lchild->_color = RBColor::BLACK;
					updateHeight(newNode->_lchild);
				}
				if (HasRChild(newNode)) {
					newNode->_rchild->_color = RBColor::BLACK;
					updateHeight(newNode->_rchild);
				}
				newNode->_color = oldColor;//新子树根节点继承原根节点的颜色
				updateHeight(newNode);//更新高度
				/*至此，就调整完毕，红黑树恢复平衡*/
			}
			/*黑s没有红孩子，及其孩子均为黑色（可能为空）,对其父亲是否为红色进行判断*/
			else {
				sibling->_color = RBColor::RED;//无论父亲是否为红色，都需要把s设为红色
				sibling->_height--;
/*2.黑s只有黑孩子（可能为空，并且其父亲为红色*/
				if (IsRed(p)) {
					p->_color = RBColor::BLACK;//直接将父亲设定为黑色，父亲的高度必然没有发生变化。
					//因为p原来为红，现在由于两个孩子高度都减了一，所以将其变成黑色后，其高度就恢复了原来的高度
					/*至此，就调整完毕，红黑树恢复平衡*/
				}
/*3.黑s只有黑孩子（可能为空，并且其父亲为黑色*/
				else {
					p->_height--;//相当于p的父亲被删，然后对p是父亲的replacer，因此，对p进行递归既可。

					solveDoubleBlack(p);//用递归时用
					/*之后可能进入1 2 3 4四种情况中的任何一种，最坏可能到根*/
				}
			}
		}
/*4.s为红，此时其必然只有黑孩子（黑孩子可能均为空），当然s的父亲p此时也必然为黑*/
		else {
			sibling->_color = RBColor::BLACK;//将s和p的颜色互换
			p->_color = RBColor::RED;

			//取与s同侧的孩子
			BinNode<T>* s_child = IsLChild(sibling) ? sibling->_lchild : sibling->_rchild;
			this->_hot = p;//首先将p的父亲记录起来

			BinNode<T>*& newNode = this->FromParentTo(p);//首先记录p的 父亲的孩子的指针
			newNode = this->rotateAt(s_child);//将s_child,s与p 进行3+4重构
			/*调整之后，树的局部结构就发生了变化*/
			solveDoubleBlack(replacer);//用递归时用

			//由第四种情况的分析，可知，只需要修复重构后的replacer就可以
			//并且之后只有可能进入第一种和第二种情况，必然不可能进入第三种情况
		}
}

（6）双黑修复迭代版~

为了方便理解，我将递归的部分变成了注释，并未进行删除，方便读者比对。

template<typename T>
void RedBlack<T>::solveDoubleBlack(BinNode<T>* replacer)
{
	while (true) {
		BinNode<T>* p = replacer ? replacer->_parent : this->_hot;
		if (p == nullptr)
			return;//如果replacer的父亲为空，则返回/*由下面的情况来分析，无论哪种情况，递归的这个节点，必然为黑色*/所以不需要考虑将根节点强转黑色

		BinNode<T>* sibling = (replacer == p->_lchild) ? p->_rchild : p->_lchild;//原来x的兄弟，也就是replacer此时的兄弟
		if (IsBlack(sibling)) {
			BinNode<T>* s_Red_child = nullptr;//sibling的红孩子（若左右孩子皆为红，则左者优先；皆黑时为nullptr）
			if (IsRed(sibling->_rchild))//需要判断sibling是不是空指针
				s_Red_child = sibling->_rchild;//右孩子
			if (IsRed(sibling->_lchild))
				s_Red_child = sibling->_lchild;//左孩子
/*1.第一种情况，黑s有红孩子*/
			if (s_Red_child != nullptr) {//如果sibling有红孩子
				RBColor oldColor = p->_color;//备份父亲的颜色

				/*接下来对s的红孩子，s以及p进行3+4重构*/
				/*根据3+4重构后的定义，其返回的节点为根节点指针，这个根节点的名字不妨设为newNode*/
				BinNode<T>*& newNode = this->FromParentTo(p);//首先记录父亲的 父亲的孩子的指针
				newNode = this->rotateAt(s_Red_child);//3+4重构
				//对3+4重构后的节点进行重染色
				if (HasLChild(newNode)) {
					newNode->_lchild->_color = RBColor::BLACK;
					updateHeight(newNode->_lchild);
				}
				if (HasRChild(newNode)) {
					newNode->_rchild->_color = RBColor::BLACK;
					updateHeight(newNode->_rchild);
				}
				newNode->_color = oldColor;//新子树根节点继承原根节点的颜色
				updateHeight(newNode);//更新高度
				/*至此，就调整完毕，红黑树恢复平衡*/

				return;//用递归的时候注释掉

			}
			/*黑s没有红孩子，及其孩子均为黑色（可能为空）,对其父亲是否为红色进行判断*/
			else {
				sibling->_color = RBColor::RED;//无论父亲是否为红色，都需要把s设为红色
				sibling->_height--;
/*2.黑s只有黑孩子（可能为空，并且其父亲为红色*/
				if (IsRed(p)) {
					p->_color = RBColor::BLACK;//直接将父亲设定为黑色，父亲的高度必然没有发生变化。
					//因为p原来为红，现在由于两个孩子高度都减了一，所以将其变成黑色后，其高度就恢复了原来的高度
					/*至此，就调整完毕，红黑树恢复平衡*/

					return;//用递归的时候注释掉
				}
/*3.黑s只有黑孩子（可能为空，并且其父亲为黑色*/
				else {
					p->_height--;//相当于p的父亲被删，然后对p是父亲的replacer，因此，对p进行递归既可。

					//solveDoubleBlack(p);//用递归时用
					replacer = p;//将replacer变成p进入迭代循环//用递归的时候注释掉

					/*之后可能进入1 2 3 4四种情况中的任何一种，最坏可能到根*/
				}
			}
		}
/*4.s为红，此时其必然只有黑孩子（黑孩子可能均为空），当然s的父亲p此时也必然为黑*/
		else {
			sibling->_color = RBColor::BLACK;//将s和p的颜色互换
			p->_color = RBColor::RED;

			//取与s同侧的孩子
			BinNode<T>* s_child = IsLChild(sibling) ? sibling->_lchild : sibling->_rchild;
			this->_hot = p;//首先将p的父亲记录起来

			BinNode<T>*& newNode = this->FromParentTo(p);//首先记录p的 父亲的孩子的指针
			newNode = this->rotateAt(s_child);//将s_child,s与p 进行3+4重构
			/*调整之后，树的局部结构就发生了变化*/
			//solveDoubleBlack(replacer);//用递归时用

			//由第四种情况的分析，可知，只需要修复重构后的replacer就可以
			//并且之后只有可能进入第一种和第二种情况，必然不可能进入第三种情况
		}
	}
}

（7）双黑修复复杂度~

邓老师已经用一个流程图和一个表格，帮助我们详细地分析了双黑修复算法的复杂度。其中zag，zig是左右旋（也就是我们的connect34重构）

其中涉及的重构、染色等局部操作，均可在常数时间内完成，故为了估计整个双黑修正过程的时间复杂度，也只需统计这些操作各自的累计执行次数。

情况BB-2-B虽可能需要反复修正，但由于待修正位置的高度严格单调上升，累计也不致过O(logn)轮，故双黑修正过程总共耗时不超过O(logn)。

即便计入此前的关键码查找和节点摘除操作，红黑树的节点删除操作总是可在O(logn)时间内完成。

一旦在某步迭代中做过节点的旋转调整，整个修复过程便会随即完成。因此与双红修正一样，双黑修正的整个过程，也仅涉及常数次的拓扑结构调整操作。

这同样也是红黑树与AVL树之间最本质的差别。（在本文章的开头，就说明了AVL的不足就在于删除时可能要多达logn次调整。）

五、完整RedBlack.h~

#pragma once
#include "BinNode.h"
#include "BST.h"

namespace my_redblack {

	using mytree::BinNode;
	using mytree::BST;
	using mytree::RBColor;
	using mytree_marcro::stature;
	using mytree_marcro::IsRoot;
	using mytree_marcro::IsLChild;
	using mytree_marcro::HasLChild;
	using mytree_marcro::HasRChild;

	template<typename T=int>
	class RedBlack :public BST<T> {
	protected:
		using BinNodePtr = BinNode<T>*;

	protected:
		void solveDoubleRed(BinNode<T>* x);//双红修正
		void solveDoubleBlack(BinNode<T>* replacer);//双黑修正
		constexpr int updateHeight(BinNode<T>* x)const override;//更新高度
		
	public:
		BinNode<T>* insert(const T& data)override;//插入重写
		bool remove(const T& data)override;//删除重写
		/*查找沿用BST的查找*/
		/*遍历沿用BinTree的遍历*/

	protected:
		static constexpr bool IsBlack(const BinNodePtr& x) {//判黑//当然x为空，也为黑色
			return ((!x) || (RBColor::BLACK == x->_color));
		}

		static constexpr bool IsRed(const BinNodePtr& x) {//非黑即红
			return !IsBlack(x);
		}

		static constexpr bool IsBlackHeightBalanced(const BinNodePtr& x) {//判断是否需要更新黑高度
			bool is_L_C_Equal = (stature(x->_lchild) == stature(x->_rchild));
			int rbHeight = (IsRed(x) ? stature(x->_lchild) : stature(x->_lchild) + 1);//对于rbHeight的计算而言，取左孩子还是右孩子，均一样
			bool is_Height_Equal = (x->_height == rbHeight);
			return is_L_C_Equal && is_Height_Equal;//只要有一个为假，即为假
													//所以只要左孩子和右孩子高度相等，或者x没有高度变化，就黑高度平衡											
		}

		static inline BinNodePtr uncle(const BinNodePtr& x) {/*获取x的叔叔*/
			return IsLChild(x->_parent) ? x->_parent->_parent->_rchild : x->_parent->_parent->_lchild;
		}

	};//class RedBlack

	template<typename T>
	constexpr int RedBlack<T>::updateHeight(BinNode<T>* x) const//由于stature视空节点高度为-1，所以height会比黑高度少一
	{
		x->_height = std::max(stature(x->_lchild), stature(x->_rchild));//孩子一般黑高度相等，除非出现双黑
		return IsBlack(x) ? x->_height++ : x->_height;//若当前节点为黑，则计入黑高度
	}

	template<typename T>
	void RedBlack<T>::solveDoubleRed(BinNode<T>* x)
	{
		while (true) {
			if (IsRoot(x)) {//若已迭代到树根，则树根转黑，整树高度也随之递增
				this->_root->_color = RBColor::BLACK;
				this->_root->_height++;
				return;
			}//否则x的父亲必然存在

			BinNode<T>* p = x->_parent;//x的父亲
			if (IsBlack(p))//如果x的父亲为黑，则终止调整
				return;//否则x的父亲必然为红，则

			BinNode<T>* g = p->_parent;//x的祖父必然存在，并且，其颜色必然为黑色
			BinNode<T>* u = uncle(x);//x的叔叔，可能为空节点

			if (IsBlack(u)) {//当u为黑色时（u为空时，也为黑色）

				//if (IsLChild(x) == IsLChild(p))
				//	p->_color = RBColor::BLACK;
				//else
				//	x->_color = RBColor::BLACK;
				//g->_color = RBColor::RED;
				/// 以上虽保证总共两次染色，但因增加了判断而得不偿失
				/// 在旋转后将根置黑、孩子置红，虽需三次染色但效率更高

				BinNode<T>*& newNode = this->FromParentTo(g);//先记录祖父的父亲的孩子指针
				newNode = this->rotateAt(x);
				/*对x进行调整，调整之后的返回值必然为调整之后的局部子树的树根位置，此时，只需要
				将此树根作为原来祖父的父亲的孩子既可，当然，高度也随之更新*/

				//重染色/*能省去之前的判断*/
				newNode->_color = RBColor::BLACK;
				newNode->_lchild->_color = RBColor::RED;
				newNode->_rchild->_color = RBColor::RED;
				return;//只要旋转了一次，就调整完整，退出循环
			}
			else {//若u为红色
				p->_color = RBColor::BLACK;//父亲此时必然为红色，将其转黑
				p->_height++;

				u->_color = RBColor::BLACK;//叔叔此时必然为红色，将其转黑
				u->_height++;

				if (!IsRoot(g))//如果祖父不为根节点，就转红
					g->_color = RBColor::RED;

				//solveDoubleRed(g);//递归用
				x = g;//将x变成其祖父，进入迭代循环。
			}
		}
	}

	template<typename T>
	BinNode<T>* RedBlack<T>::insert(const T& data)
	{
		BinNode<T>*& x = this->search(data);//沿用BST的查找//并更新_hot//用引用接收
		if (x)//如果节点存在，则返回
			return x;
		x = new BinNode<T>(data, this->_hot, nullptr, nullptr, -1);//设定黑高度-1，并默认节点为红色
		this->_size++;
		solveDoubleRed(x);//双红修正//x此时必为红
		return x;
	}

	template<typename T>
	void RedBlack<T>::solveDoubleBlack(BinNode<T>* replacer)
	{
		while (true) {
			BinNode<T>* p = replacer ? replacer->_parent : this->_hot;
			if (p == nullptr)
				return;//如果replacer的父亲为空，则返回/*由下面的情况来分析，无论哪种情况，递归的这个节点，必然为黑色*/所以不需要考虑将根节点强转黑色

			BinNode<T>* sibling = (replacer == p->_lchild) ? p->_rchild : p->_lchild;//原来x的兄弟，也就是replacer此时的兄弟
			if (IsBlack(sibling)) {
				BinNode<T>* s_Red_child = nullptr;//sibling的红孩子（若左右孩子皆为红，则左者优先；皆黑时为nullptr）
				if (IsRed(sibling->_rchild))//需要判断sibling是不是空指针
					s_Red_child = sibling->_rchild;//右孩子
				if (IsRed(sibling->_lchild))
					s_Red_child = sibling->_lchild;//左孩子
	/*1.第一种情况，黑s有红孩子*/
				if (s_Red_child != nullptr) {//如果sibling有红孩子
					RBColor oldColor = p->_color;//备份父亲的颜色

					/*接下来对s的红孩子，s以及p进行3+4重构*/
					/*根据3+4重构后的定义，其返回的节点为根节点指针，这个根节点的名字不妨设为newNode*/
					BinNode<T>*& newNode = this->FromParentTo(p);//首先记录父亲的 父亲的孩子的指针
					newNode = this->rotateAt(s_Red_child);//3+4重构
					//对3+4重构后的节点进行重染色
					if (HasLChild(newNode)) {
						newNode->_lchild->_color = RBColor::BLACK;
						updateHeight(newNode->_lchild);
					}
					if (HasRChild(newNode)) {
						newNode->_rchild->_color = RBColor::BLACK;
						updateHeight(newNode->_rchild);
					}
					newNode->_color = oldColor;//新子树根节点继承原根节点的颜色
					updateHeight(newNode);//更新高度
					/*至此，就调整完毕，红黑树恢复平衡*/

					return;//用递归的时候注释掉

				}
				/*黑s没有红孩子，及其孩子均为黑色（可能为空）,对其父亲是否为红色进行判断*/
				else {
					sibling->_color = RBColor::RED;//无论父亲是否为红色，都需要把s设为红色
					sibling->_height--;
	/*2.黑s只有黑孩子（可能为空，并且其父亲为红色*/
					if (IsRed(p)) {
						p->_color = RBColor::BLACK;//直接将父亲设定为黑色，父亲的高度必然没有发生变化。
						//因为p原来为红，现在由于两个孩子高度都减了一，所以将其变成黑色后，其高度就恢复了原来的高度
						/*至此，就调整完毕，红黑树恢复平衡*/

						return;//用递归的时候注释掉
					}
	/*3.黑s只有黑孩子（可能为空，并且其父亲为黑色*/
					else {
						p->_height--;//相当于p的父亲被删，然后对p是父亲的replacer，因此，对p进行递归既可。

						//solveDoubleBlack(p);//用递归时用
						replacer = p;//将replacer变成p进入迭代循环//用递归的时候注释掉

						/*之后可能进入1 2 3 4四种情况中的任何一种，最坏可能到根*/
					}
				}
			}
	/*4.s为红，此时其必然只有黑孩子（黑孩子可能均为空），当然s的父亲p此时也必然为黑*/
			else {
				sibling->_color = RBColor::BLACK;//将s和p的颜色互换
				p->_color = RBColor::RED;

				//取与s同侧的孩子
				BinNode<T>* s_child = IsLChild(sibling) ? sibling->_lchild : sibling->_rchild;
				this->_hot = p;//首先将p的父亲记录起来

				BinNode<T>*& newNode = this->FromParentTo(p);//首先记录p的 父亲的孩子的指针
				newNode = this->rotateAt(s_child);//将s_child,s与p 进行3+4重构
				/*调整之后，树的局部结构就发生了变化*/
				//solveDoubleBlack(replacer);//用递归时用

				//由第四种情况的分析，可知，只需要修复重构后的replacer就可以
				//并且之后只有可能进入第一种和第二种情况，必然不可能进入第三种情况
			}
		}
	}

	template<typename T>
	bool RedBlack<T>::remove(const T& data)
	{
		BinNode<T>*& x = this->search(data);//找有没有这个节点，如果没有，则返回false,记住用引用
		if (!x)
			return false;
		BinNode<T>* replacer = removeAt(x, this->_hot);//调用在BST定义的全局静态函数removeAt,返回被删除节点的接替者，同时更新_hot

		--this->_size;//更新规模
		//1.如果这个被删除节点是树中唯一节点，则直接返回
		if (this->_size==0) {
			this->_root = nullptr;//将根节点置空
			return true;
		}

		//2.如果被删除节点为根节点，则_hot必然为空//但如果进行到此，说明此时_root必然不为空，不然上一就会退出
		if (this->_hot == nullptr) {
			this->_root->_color = RBColor::BLACK;//就将此时的根节点直接染成黑色
			updateHeight(this->_root);//并更新根节点的高度
			return true;
		}//如果进行到此，说明被删除节点必然存在，并且不为根节点。_hot也必然存在

		/*3.如果_hot的黑高度不变则返回*/
		/*此时也必然包括了被删除节点为红色节点的情况，若为红色，则删除对高度没有影响*/
		/*当然，也包括了双黑的可能情况*/
		if (IsBlackHeightBalanced(this->_hot))
			return true;

		/*4.如果_hot的黑高度变了，说明被删除节点必然为黑色*/
		if (IsRed(replacer)) {//就看x的接替者是不是红色，如果是红色，将其染成黑色，就必然可以使树的高度恢复。
			replacer->_color = RBColor::BLACK;
			replacer->_height++;
			return true;
		}

		/*5.如果进行到此，就必然说明被删除节点和replacer均为黑色节点（replacer可能为空），此时，就需要进行双黑缺陷判断*/
		/*要进行到这里的条件即为被删除节点的父亲的黑高度变了，并且被删除节点的接替者也为黑色时。*/
		solveDoubleBlack(replacer);
		return true;
	}

}//namespace my_redblack

六、红黑树测试~

1.插入测试代码~

#include
#include "RedBlack.h"
using namespace std;
using namespace my_redblack;

template<typename BinNodePtr>
void visite(BinNodePtr x) {
	cout << "数据为：" << x->_data << " ";
	if (x->_color == RBColor::RED) {
		cout << "颜色为：" << "红" << " ";
	}
	else {
		cout << "颜色为：" << "黑" << " ";
	}
	cout << endl;
}
int main() {

	RedBlack r;
	for (int i = 0; i < 10; ++i) {
		r.insert(i);
	}
	cout << "层次遍历为：" << endl;
	r.travLevel(visite<BinNode<int>*>);
	cout << endl;

	cout << "先序遍历为：" << endl;
	r.travPre(visite<BinNode<int>*>);
	cout << endl;

	cout << "中序遍历为：" << endl;
	r.travIn(visite<BinNode<int>*>);
	cout << endl;

	cout << "后序遍历为：" << endl;
	r.travPost(visite<BinNode<int>*>);
	cout << endl;
	return 0;
}

层次遍历为：
数据为：3 颜色为：黑
数据为：1 颜色为：黑
数据为：5 颜色为：黑
数据为：0 颜色为：黑
数据为：2 颜色为：黑
数据为：4 颜色为：黑
数据为：7 颜色为：红
数据为：6 颜色为：黑
数据为：8 颜色为：黑
数据为：9 颜色为：红

先序遍历为：
数据为：3 颜色为：黑
数据为：1 颜色为：黑
数据为：0 颜色为：黑
数据为：2 颜色为：黑
数据为：5 颜色为：黑
数据为：4 颜色为：黑
数据为：7 颜色为：红
数据为：6 颜色为：黑
数据为：8 颜色为：黑
数据为：9 颜色为：红

中序遍历为：
数据为：0 颜色为：黑
数据为：1 颜色为：黑
数据为：2 颜色为：黑
数据为：3 颜色为：黑
数据为：4 颜色为：黑
数据为：5 颜色为：黑
数据为：6 颜色为：黑
数据为：7 颜色为：红
数据为：8 颜色为：黑
数据为：9 颜色为：红

后序遍历为：
数据为：0 颜色为：黑
数据为：2 颜色为：黑
数据为：1 颜色为：黑
数据为：4 颜色为：黑
数据为：6 颜色为：黑
数据为：9 颜色为：红
数据为：8 颜色为：黑
数据为：7 颜色为：红
数据为：5 颜色为：黑
数据为：3 颜色为：黑

2.插入测试图示~

3.删除测试代码~

#include
#include "RedBlack.h"
using namespace std;
using namespace my_redblack;

template<typename BinNodePtr>
void visite(BinNodePtr x) {
	cout << "数据为：" << x->_data << " ";
	if (x->_color == RBColor::RED) {
		cout << "颜色为：" << "红" << " ";
	}
	else {
		cout << "颜色为：" << "黑" << " ";
	}
	cout << endl;
}
int main() {

	RedBlack r;
	for (int i = 0; i < 10; ++i) {
		r.insert(i);
	}
	cout << "中序遍历为：" << endl;
	r.travIn(visite<BinNode<int>*>);
	cout << endl;

	for (int i = 0; i < 10; ++i) {
		r.remove(i);
		r.travIn(visite<BinNode<int>*>);
		cout << endl;
	}
	return 0;
}

中序遍历为：
数据为：0 颜色为：黑
数据为：1 颜色为：黑
数据为：2 颜色为：黑
数据为：3 颜色为：黑
数据为：4 颜色为：黑
数据为：5 颜色为：黑
数据为：6 颜色为：黑
数据为：7 颜色为：红
数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：1 颜色为：黑
数据为：2 颜色为：红
数据为：3 颜色为：黑
数据为：4 颜色为：黑
数据为：5 颜色为：黑
数据为：6 颜色为：黑
数据为：7 颜色为：黑
数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：2 颜色为：黑
数据为：3 颜色为：黑
数据为：4 颜色为：黑
数据为：5 颜色为：黑
数据为：6 颜色为：黑
数据为：7 颜色为：黑
数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：3 颜色为：黑
数据为：4 颜色为：红
数据为：5 颜色为：黑
数据为：6 颜色为：黑
数据为：7 颜色为：红
数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：4 颜色为：黑
数据为：5 颜色为：黑
数据为：6 颜色为：黑
数据为：7 颜色为：红
数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：5 颜色为：黑
数据为：6 颜色为：红
数据为：7 颜色为：黑
数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：6 颜色为：黑
数据为：7 颜色为：黑
数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：7 颜色为：黑
数据为：8 颜色为：黑
数据为：9 颜色为：黑

数据为：8 颜色为：黑
数据为：9 颜色为：红

数据为：9 颜色为：黑

4.删除测试图示~

七、结语~

本系列文章，总共6篇，分别介绍了

基本二叉树节点（1w9字）
基本二叉树类（6000字）
BST（1w2字）
AVL（1w1字）
B树（1w5字）
红黑树（2w8字）

其中B树和红黑树的难度最大的，这两种树情况分析确实十分复杂，除非背下来，不然是不可能在短时间内一下就能分析出这么多情况，并且不发生遗漏的。

在此，再次感谢邓老师的教材和视频，我才能够掌握树的核心框架。并且感谢发明这些树的前辈们，多亏了他们的智慧，才有了这些高效的数据结构和算法的出现，提高了我们的计算机处理问题的能力。

并且不知不觉，算上代码，此系列文章也写了将近9w字。零零散散大概写了两个星期左右。初衷是想要锻炼一下c++的编程能力以及数据结构和算法。但写着写着就想尽可能地将内容完善，简洁，并且简单易懂地描述各种插入和删除的过程。

我相信，只要你从头看下来，你对树的理解必然会上升一个档次。如果你对某些地方的算法有所困惑，那不妨将其手敲一遍，对照着文章再看一遍，或者看下邓老师的书和讲解，你一定能理解这里为什么要用这种算法。

c++就我个人理解而言，是一门非常严谨的语言。写c++代码的时候，要考虑的因素很多，因此可能初学起来相对java，c#等语言而言，会感到进度缓慢，但只要入门了之后，特别是了解了c++11常用特性，以及c++的常用语法之后，你会对c++越来越喜爱，也会明白为什么c++是世界上效率最高的语言。

废话不多说，感谢你能耐心看完我精心准备的此系列文章，虽然我已经和邓老师的代码的各个实现进行了比对，但难免会有所遗漏之处，希望广大读者能够即时进行指正。

如果你觉得对你有用，请不要光收藏，你的赞是我继续分享好东西的动力。

另外，借用侯捷大师的话：

学一个东西，不知道其道理，不高明！

你可能感兴趣的:(C++数据结构与算法)

【OpenCV C++】存图，如何以时间命名，“年月日-时分秒“产生唯一的文件名呢？“年月日-时分秒-毫秒“ 自动检查存储目录，若不存在自动创建存图 R-G-B OpenCV C++C/C++opencv c++人工智能
文章目录1生成文件名（格式:"年月日-时分秒"格式）2生成文件名（格式:"年月日-时分秒-毫秒"）3多模式存图函数4综合调用实例5注意：默认参数只能在头文件中定义，不能在实现中重复默认参数mode==1→“年月日-时分”→YYYYMMDD-HHMM的文件名；例如：20250310-1647mode==2→"年月日-时分秒-毫秒"→YYYYMMDD-HHMMSS-MMM（适用采集存储帧率搞得图片，增
C++：const和constexpr两个关键字壹十壹 C++c++
在C++中，constexpr和const是两个关键字，用于定义常量，但它们有不同的语义和用途。以下是它们的详细对比和示例：1.const含义：表示变量是只读的，其值在程序运行期间不能被修改。初始化：可以在运行时（run-time）进行初始化。用法：通常用于修饰变量、函数参数或返回值。不能保证变量在编译期求值。示例constintx=10;//编译时常量inty=20;constintz=y;//
qt c++线程中的同步和异步我要进步！ qt c++
一、线程同步用于协调多个线程对共享资源的访问，避免竞态条件。常用工具：QMutex（互斥锁）保护临界区，确保一次仅一个线程访问资源。QMutexmutex;intsharedData=0;voidThread::run(){mutex.lock();sharedData++;//安全操作mutex.unlock();}QMutexLocker自动管理锁生命周期：{QMutexLockerlocke
C++ time(0)函数宁玉AC c学习
time(0)函数返回当前格林尼治标准时间与格林尼治标准时间1970年0分0秒的时间间隔。头文件#include//问题：得到当前时间。#include#includeusingnamespacestd;intmain(){inttotalSeconds=time(0);intcurrentSeconds=totalSeconds%60;inttotalMinutes=totalSeconds/6
C++随机数宁玉AC c学习 c++开发语言
目录一、名著参考二、详解1.rand()函数2.time(0)3.srand(time(0))4.获取指定范围内的随机数（含指定位数）一、名著参考可以使用cstdlib头文件中的rand()函数来获得随机整数；这个函数返回0~RAND_MAX之间的随机整数；rand()函数生成的是伪随机数。即每次在同一个系统上执行这个函数的时候，rand()函数生成同一序列的数。rand()函数的算法使用一个叫种
C++11之列表初始化 Octopus2077 c++学习笔记
发展历史C++11是C++的第⼆个主要版本，并且是从C++98起的最重要更新。它引⼊了⼤量更改，标准化了既有实践，并改进了对C++程序员可⽤的抽象。在它最终由ISO在2011年8⽉12⽇采纳前，⼈们曾使⽤名称“C++0x”，因为它曾被期待在2010年之前发布。C++03与C++11期间花了8年时间，故⽽这是迄今为⽌最⻓的版本间隔。从那时起，C++有规律地每3年更新⼀次。列表初始化（注意区分列表初始
刷题前必学！二叉树！用JavaScript学数据结构与算法
‍JavaScript算法与数据结构-HowieCong务必要熟悉JavaScript使用再来学！一、树是什么？数据结构中的树，对于现实世界中的树简化——树根抽象为“根节点”，树枝抽象为“边”，树枝的两个端点抽象为“结点”，树叶抽象为“叶子结点”计算机中的树如下：二、树的重点树的层次计算规则：根结点所在的那一层为第一层，其子节点为第二层，以此类推结点和树的高度计算规则：叶子结点高度为1，每向上一层
基于llama_cpp 调用本地模型（llama）实现基本推理月光技术杂谈大模型初探 llama llama.cpp python LLM 集成显卡本地模型 AI
零基础实践本地推理模型基本应用：基于llama_cpp的本地模型调用。本文先安装llama_cpppython库，再编写程序，利用其调用llama-2-7b-chat.Q4_K_M.ggu模型。背景llama_cpp是一个基于C++的高性能库（llama.cpp）的Python绑定，支持在CPU或GPU上高效运行LLaMA及其衍生模型（如LLaMA2），并通过量化技术（如GGUF格式）优化内存使用
动态规划双剑合璧：C++与Python征服洛谷三大经典DP问题三流搬砖艺术家动态规划 c++python
动态规划核心思想状态定义→转移方程→边界处理→时空优化本文精选洛谷动态规划题单中三大经典问题，通过C++与Python双语言对比实现，彻底掌握DP精髓！题目一：P1048采药（01背包模板）题目描述在限定时间T内采集草药，每株草药有采集时间time[i]和价值value[i]，求最大总价值。解题思路状态定义：dp[j]表示时间j能获得的最大价值转移方程：dp[j]=max(dp[j],dp[j-t
C语言_数据结构总结7:顺序队列（循环队列） *.✧屠苏隐遥(ﾉ◕ヮ◕)ﾉ*.✧ C语言—数据结构数据结构 c语言开发语言算法 visual studio visualstudio
纯C语言实现，不涉及C++队列简称队，也是一种操作受限的线性表。只允许表的一端进行插入，表的另一端进行删除特性：先进先出针对顺序队列存在的“假溢出”问题，引出的循环队列概念。循环队列将顺序队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上视为一个环。当队首指针Q->front=MaxSize-1后，再前进一个位置就自动到0，这可以利用除法取余运算（%）来实现。循环队列中的判空和判满条件分析：显
C++：入门详解（关于C与C++基本差别）梅茜Mercy c++c语言 java
目录一.C++的第一个程序二.命名空间（namespace）1.命名空间的定义与使用：（1）命名空间里可以定义变量，函数，结构体等多种类型（2）命名空间调用（：：）与展开（3）命名空间的嵌套（4）具体使用场景三.缺省参数1.基本定义：2.几个注意：四.函数重载1.定义与使用：五.引用1.定义：2.引用的特性：3.引用的使用（区别传值返回和传引用返回）：4.const引用：六.inline内联一.C
C++开源库大全大王算法 C/C++开发实战365 C++入门及项目实战宝典 c++开源
程序员要站在巨人的肩膀上，C++拥有丰富的开源库，这里包括：标准库、Web应用框架、人工智能、数据库、图片处理、机器学习、日志、代码分析等。标准库C++StandardLibrary：是一系列类和函数的集合，使用核心语言编写，也是C++ISO自身标准的一部分。
C++11使用mutex和condition_variable实现线程同步追烽少年x C++基础 c++
C++11使用mutex和condition_variable实现线程同步在实现项目的过程中，突然有一个问题：C++中A、B、C三个线程模拟购买100张车票，A输出99，B输出98，C输出97,然后又循环A输出96，B95,C94,直到0，使用线程同步，如何实现？这是一种按顺序执行线程的问题，应该实现？代码如下：#include#include#include#include#include//共
c++计算n的阶乘（用循环和递归） Absinthe_苦艾酒 c/c++c++算法数据结构
1.循环//计算阶乘#includeusingnamespacestd;intfct(int*p){intsum=1;while(*p>=2){sum*=((*p)--);}returnsum;}intmain(){cout>n;coutusingnamespacestd;//使用递归计算阶乘intfct(intn){if(n==1)return1;elsereturnn*fct(n-1);}in
树莓派-C++之异常 lalalaouhei c++开发语言后端
2021SC@SDUSCC++异常用官方的话来说就是程序在执行过程中产生的问题，换句通俗的话来讲就是程序执行的出现的异常，比如程序崩了、内存泄漏了、数组越界以及其他异常信息的出现，又如运行时耗尽了内存或遇到意外的非法输入。一个简单的例子就是尝试除以零的操作。异常存在于程序的正常功能之外，并要求程序立即处理。不能不处理异常，异常是足够重要的，使程序不能继续正常执行的事件。一、异常处理所谓“处理”，可
C++中map和set的详解 jiajia651304 c++算法开发语言
C++中map和set的介绍与使用一、map的介绍与使用二、set的介绍与使用三、总结在C++编程中，map和set是标准模板库（STL）中两种非常重要的关联容器。它们基于平衡二叉搜索树（通常是红黑树）的数据结构来实现，提供了高效的数据存储和检索功能。本文将详细介绍map和set的特点、用法以及一些常见的操作示例。一、map的介绍与使用1.map的基本概念map是一个键值对容器，其中每个键都是唯一
Qt基础之四十一：记一次QVector的bad alloc问题追踪草上爬 Qt那些事儿 qt QVector vector bad alloc
目录一.QVector的特点二.QVector的内存分配策略三.badalloc问题追踪一.QVector的特点QVector是Qt容器类库中的一个重要组成部分，它提供了类似于C++标准库中的std::vector的功能，但同时拥有Qt独特的优势。QVector是一个动态数组，支持添加、插入和删除元素。与其他容器相比，QVector在随机访问元素时具有出色的性能，同时在尾部添加和删除元素时依然高效
C++内存操纵的艺术 longdong7889 后端学习 c++java 开发语言
C++内存操纵的艺术在C++的混沌宇宙中，指针是打开时空裂缝的密钥。本文将以全新视角解构指针的本质，揭示从堆栈穿梭到多维空间映射的进阶技法，展示现代C++赋予指针的惊人可能性。一、指针本体论：内存的波粒二象性所有指针变量都是量子化的存在，既指向具体内存位置，又携带类型信息波。通过类型系统实验可验证其双重属性：templatevoidquantum_observer(T*ptr){std::cout
C++入门之容易忽视的namespace和函数重载不会的码 c++开发语言后端
目录命名空间命名空间的定义命名空间的用法1.直接把std整个展开2.对部分常用的展开3.指定命名空间缺省参数全缺省：（所有的参数都指定一个默认值）半缺省：(只有部分被参数指定默认值，而不是一半的参数)函数重载那么为什么C语言不支持函数重载，C++支持呢？extern"C"命名空间在C/C++中，变量、函数都是大量存在的，这些变量、函数的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的
C++内存管理秘籍：深入解析与实战代码示例 my1121716951 编程 c++java 开发语言
C++内存管理秘籍：深入解析与实战代码示例一、内存管理的基本概念二、内存泄漏与野指针三、智能指针：现代C++的内存管理利器四、实战代码示例示例1：传统动态内存管理示例2：使用`std::unique_ptr`示例3：使用`std::shared_ptr`五、总结在C++编程的世界里，内存管理是一项既基础又核心的技能。它直接关系到程序的性能、稳定性和可维护性。不同于一些高级语言自动管理内存的特性，C
C++之list删除元素 csdn_zhangchunfeng C++VS 技术管理索引列表 c++
C++之list删除元素对容器list存储的元素执行删除操作的时候，一般都是使用其成员函数实现的：（1）clear（）：删除list容器中的所有元素（2）remove（value）：删除容器中所有为value的元素（3）remove_if（）：删除容器中满足条件的元素（4）unique（）：删除容器中相邻的重复元素，只留下一个（5）erase（）：删除list容器中指定位置处的元素，也可以删除容器
【C++基础学习笔记】C++的输入输出流及缺省参数大家好我叫张同学深入浅出学习C++c++
我要做一个好奇宝宝，带着疑问来阅读，哼~C++如何进行输入输出？和C语言何有区别？C++的缺省参数是什么？如何理解和掌握？文章目录C++的输入&输出缺省参数缺省参数的概念缺省参数的分类1.全缺省参数2.半缺省参数：C++的输入&输出婴儿降生到这个世界上时，会以自己独特的方式向这个崭新的世界打招呼。跟新生婴儿类似，C++语言刚出来后，也算是一个新事物，作为一门新的编程语言也会有自己问候这个美好世界的
C++之string类讨厌下雨的天空 c++
1.string类的重要性：C语言中，字符串是以“\0”结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OPP的思想，而且底层空间需要用户自行管理，稍不留神可能会越界访问。string是一个对象，使用字符的顺序表实现的，就是一个字符顺序表。基本构造：classstring{private:size_tsize;size_tcap
C++——list 回首o c++开发语言
目录前言一、list1.1list的介绍1.2list的使用1.2.1list的构造1.2.2listiterator的使用1.2.3listcapacity1.2.4listelementaccess1.2.5listmodifiers1.2.6list的迭代器失效二、list的模拟实现2.1模拟实现list三、list与vector的对比总结前言今天我们来了解C++中STL库中的list，相当
快速从C过度C++（一）：namespace，C++的输入和输出，缺省参数，函数重载愚润泽 C++学习笔记 c++开发语言 c语言
前言：本文章适合有一定C语言编程基础的读者浏览，主要介绍从C语言到C++过度，我们首先要掌握的一些基础知识，以便于我们快速进入C++的学习，为后面的学习打下基础。这篇文章的主要内容有：1，命名空间namespace2，C++的输入和输出3，缺省参数4，函数重载个人简介：努力学习ing个人专栏：C++学习笔记CSDN主页愚润求学其他专栏：C语言入门基础，python入门基础，python刷题专栏快速
C++——std::Set zy2317878 C++
写在前面：在写这篇博客之前吐个槽，其实也可不不用这么麻烦这么写博客。讲道理其实在书本上学这些知识应该挺快的。可以书上看一遍记个大概，然后做题的过程中，不断遇见各种小知识，这样分散的积累，然后一定规模后，就可以系统的整理。但是现在先花时间来做这件事，其实也可以，建立主体的框架，后面再慢慢细化丰富。也没必要想那么多，慢慢来。不管方法是什么，重要的是每天要做点事。那么这篇博客学习set容器。目前学习了v
C++第六节：stack和queue 熊峰峰 #C++c++开发语言
本节目标：stack的介绍与使用queue的介绍与使用priority_queue的介绍与使用容器适配器模拟实现与结语1stack（堆）的介绍stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，只能从容器的一端进行元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定
C++ 各种容器的详细说明 (td::vector、std::list、std::deque、std::set、std::map 和 std::unordered_map) david_bang_1980 c++开发语言
C++标准库提供了多种容器，用于存储和管理数据。每种容器都有其独特的特点和适用场景。本文将详细介绍几种常见的C++容器，包括std::vector、std::list、std::deque、std::set、std::map和std::unordered_map等。1.std::vector概述std::vector是一个动态数组，能够自动调整大小。它在内存中连续存储元素，支持快速随机访问。主要特
第十二届蓝桥杯大赛软件类省赛C++研究生组 _tomorrow 算法练习算法蓝桥杯
题目A卡片（5分，√）B直线（5分，√）C货物摆放（10分，√）D路径（10分，√）E回路计数（15分，√）F时间显示（15分，√）G砝码称重（20分，√）H异或数列（20分）I双向排序（25分）J分果果（25分）题目是全的，但是由于能力有限，后面有题目没做，分值和完成情况在题目后说明A卡片（5分，√）题目描述本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。小蓝有很多数字卡
动态规划经典算法详解与C++实现金外飞176 算法算法动态规划 c++
动态规划经典算法详解与C++实现动态规划（DynamicProgramming）是解决复杂问题的重要方法，通过将问题分解为重叠子问题并记录中间结果实现高效计算。本文精选六大经典动态规划问题，提供详细的算法解析和C++实现代码。一、斐波那契数列（基础入门）算法原理通过存储已计算结果避免重复计算，时间复杂度从O(2^n)优化到O(n)状态转移方程dp[i]=dp[i-1]+dp[i-2]C++实现#i
312个免费高速HTTP代理IP（能隐藏自己真实IP地址） yangshangchuan 高速免费 superword HTTP代理
124.88.67.20:843 190.36.223.93:8080 117.147.221.38:8123 122.228.92.103:3128 183.247.211.159:8123 124.88.67.35:81 112.18.51.167:8123 218.28.96.39:3128 49.94.160.198:3128 183.20
pull解析和json编码百合不是茶 android pull解析 json
n.json文件: [{name:java,lan:c++,age:17},{name:android,lan:java,age:8}] pull.xml文件 <?xml version="1.0" encoding="utf-8"?> <stu> <name>java
[能源与矿产]石油与地球生态系统 comsci 能源
按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的.... 那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
类与对象浅谈沐刃青蛟 java 基础
类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
新站开始被收录后，我们应该做什么？ IT独行者 PHP seo
新站开始被收录后，我们应该做什么？百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
oracle 连接碰到的问题文强chu oracle
Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案作者：草根IT网来源：未知人气：813标签：导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据）小桔子 java 继承 swing 接口监听
都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
linux常用的命令 aichenglong linux 常用命令
1 startx切换到图形化界面 2 man命令:查看帮助信息 man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分 name:对命令的简单说明 synopsis:命令的使用格式说明 description:命令的详细说明信息 options:命令的各项说明 3 date:显示时间语法：date [OPTION]... [+FORMAT]
eclipse内存优化 AILIKES java eclipse jvm jdk
一基本说明在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。 1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
关键字的使用探讨百合不是茶关键字
//关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的只能在包中访问*//*final 类方法变量 final 类不能被继承 final 方法不能被子类覆盖，但可以继承 final 变量只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
JS中定义对象的几种方式 bijian1013 js
1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)： <html> <head> <title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title> </head> <script> var obj = new Object();
表驱动法实例 bijian1013 java 表驱动法 TDD
获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下： MonthDaysTest.java package com.study.test; import org.junit.Assert; import org.junit.Test; import com.study.MonthDays; public class MonthDaysTest { @T
LInux启停重启常用服务器的脚本 bit1129 linux
启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改 #! /bin/bash Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo); Ops=(Start, Stop, Restart); currentDir=$(pwd); echo
【HBase六】REST操作HBase bit1129 hbase
HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作 1. 启动和停止HBase REST 服务 1.1 启动REST服务前台启动（默认端口号8080） [hadoop@hadoop bin]$ ./hbase rest start 后台启动 hbase-daemon.sh start rest 启动时指定
大话zabbix 3.0设计假设 ronin47
What’s new in Zabbix 2.0? 去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个： :: Performance improvements::Trigger related da
http错误码大全 byalias http协议 javaweb
响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。响应码分五种类型，由它们的第一位数字表示： 1）1xx：信息，请求收到，继续处理 2）2xx：成功，行为被成功地接受、理解和采纳 3）3xx：重定向，为了完成请求，必须进一步执行的动作 4）4xx：客户端错误，请求包含语法错误或者请求无法实现 5）5xx：服务器错误，服务器不能实现一种明显无效的请求
J2EE设计模式-Intercepting Filter bylijinnan java 设计模式数据结构
Intercepting Filter类似于职责链模式有两种实现其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下： package com.ljn.filter.custom; import java.util.ArrayList;
修改jboss端口 chicony jboss
修改jboss端口 %JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml 中找到 <!-- The ports-default bindings are obtained by taking the base bindin
c++ 用类模版实现数组类 CrazyMizzz C++
最近c++学到数组类，写了代码将他实现，基本具有vector类的功能 #include<iostream> #include<string> #include<cassert> using namespace std; template<class T> class Array { public: //构造函数
hadoop dfs.datanode.du.reserved 预留空间配置方法 daizj hadoop 预留空间
对于datanode配置预留空间的方法为：在hdfs-site.xml添加如下配置 <property> <name>dfs.datanode.du.reserved</name> <value>10737418240</value>
mysql远程访问的设置 dcj3sjt126com mysql 防火墙
第一步: 激活网络设置你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
ios 使用特定的popToViewController返回到相应的Controller dcj3sjt126com controller
1、取navigationCtroller中的Controllers NSArray * ctrlArray = self.navigationController.viewControllers; 2、取出后，执行， [self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
Linux正则表达式和通配符的区别 eksliang 正则表达式通配符和正则表达式的区别通配符
转载请出自出处：http://eksliang.iteye.com/blog/1976579 首先得明白二者是截然不同的通配符只能用在shell命令中,用来处理字符串的的匹配。判断一个命令是否为bash shell(linux 默认的shell)的内置命令 type -t commad 返回结果含义 file 表示为外部命令 alias 表示该
Ubuntu Mysql Install and CONF gengzg Install
http://www.navicat.com.cn/download/navicat-for-mysql Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html Step2：进入下载目录，解压压缩包：tar -zxvf navicat11_mysql_en.tar.gz
批处理，删除文件bat huqiji windows dos
@echo off ::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。 ::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。 ::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log） rem 指定待删除文件的存放路径 set SrcDir=C:/Test/BatHome rem 指定天数 set DaysAgo=1
跨浏览器兼容的HTML5视频音频播放器天梯梦 html5
HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。 How to enable <video> and <audio> tags in
Bundle自定义数据传递 hm4123660 android Serializable 自定义数据传递 Bundle Parcelable
我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity 把数据放到Intent
C＃：异步编程和线程的使用（.NET 4.5 ） powertoolsteam .net 线程 C#异步编程
异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。本文中涉及关键知识点 1. 异步编程 2. 线程的使用 3. 基于任务的异步模式 4. 并行编程 5. 总结异步编程什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
spark 查看 job history 日志 Stark_Summer 日志 spark history job
SPARK_HOME/conf 下: spark-defaults.conf 增加如下内容 spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true spark-env.sh 增加如下内容 export SP
SSH框架搭建 wangxiukai2015eye spring Hibernate struts
MyEclipse搭建SSH框架 Struts Spring Hibernate 1、new一个web project。 2、右键项目，为项目添加Struts支持。选择Struts2 Core Libraries -<MyEclipes-Library> 点击Finish。src目录下多了struts