STL源码剖析---红黑树原理详解上

红黑树原理与插入操作
最新推荐文章于 2025-04-11 12:39:48 发布
转载 最新推荐文章于 2025-04-11 12:39:48 发布 · 453 阅读 · 0

STL源码剖析---红黑树原理详解上       

       
数据结构 null

一、红黑树概述

     红黑树和我们以前学过的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。不过自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。这一点在我们了解了红黑树的实现原理后，就会有更加深切的体会。
     红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严格的平衡。学过数据结构的人应该都已经领教过AVL树的复杂，但AVL树的复杂比起红黑树来说简直是小巫见大巫，红黑树才是真正的变态级数据结构。
     由于STL中的关联式容器默认的底层实现都是红黑树，因此红黑树对于后续学习STL源码还是很重要的，有必要掌握红黑树的实现原理和源码实现。
     红黑树是AVL树的变种，红黑树通过一些着色法则确保没有一条路径会比其它路径长出两倍，因而达到接近平衡的目的。所谓红黑树，不仅是一个二叉搜索树，而且必须满足一下规则：
     1、每个节点不是红色就是黑色。
     2、根节点为黑色。
     3、如果节点为红色，其子节点必须为黑色。
     4、任意一个节点到到NULL（树尾端）的任何路径，所含之黑色节点数必须相同。
上面的这些约束保证了这个树大致上是平衡的，这也决定了红黑树的插入、删除、查询等操作是比较快速的。 根据规则4，新增节点必须为红色；根据规则3，新增节点之父节点必须为黑色。当新增节点根据二叉搜索树的规则到达其插入点时，却未能符合上述条件时，就必须调整颜色并旋转树形，如下图：

假设我们为上图分别插入节点3、8、35、75，根据二叉搜索树的规则，插入这四个节点后，我们会发现它们都破坏了红黑树的规则，因此我们必须调整树形，也就是旋转树形并改变节点的颜色。

二、红黑树上结点的插入

      在讨论红黑树的插入操作之前必须要明白，任何一个即将插入的新结点的初始颜色都为红色。这一点很容易理解，因为插入黑点会增加某条路径上黑结点的数目，从而导致整棵树黑高度的不平衡。但如果新结点的父结点为红色时（如下图所示），将会违反红黑树的性质：一条路径上不能出现相邻的两个红色结点。这时就需要通过一系列操作来使红黑树保持平衡。

      为了清楚地表示插入操作以下在结点中使用“新”字表示一个新插入的结点；使用“父”字表示新插入点的父结点；使用“叔”字表示“父”结点的兄弟结点；使用“祖”字表示“父”结点的父结点。插入操作分为以下几种情况：
1、黑父
     如下图所示，如果新节点的父结点为黑色结点，那么插入一个红点将不会影响红黑树的平衡，此时插入操作完成。红黑树比AVL树优秀的地方之一在于黑父的情况比较常见，从而使红黑树需要旋转的几率相对AVL树来说会少一些。

2、红父
     如果新节点的父结点为红色，这时就需要进行一系列操作以保证整棵树红黑性质。如下图所示，由于父结点为红色，此时可以判定，祖父结点必定为黑色。这时需要根据叔父结点的颜色来决定做什么样的操作。青色结点表示颜色未知。由于有可能需要根结点到新点的路径上进行多次旋转操作，而每次进行不平衡判断的起始点（我们可将其视为新点）都不一样。所以我们在此使用一个蓝色箭头指向这个起始点，并称之为判定点。

2.1 红叔
当叔父结点为红色时，如下图所示，无需进行旋转操作，只要将父和叔结点变为黑色，将祖父结点变为红色即可。但由于祖父结点的父结点有可能为红色，从而违反红黑树性质。此时必须将祖父结点作为新的判定点继续向上（迭代）进行平衡操作。

需要注意的是，无论“父节点”在“叔节点”的左边还是右边，无论“新节点”是“父节点”的左孩子还是右孩子，它们的操作都是完全一样的（其实这种情况包括4种，只需调整颜色，不需要旋转树形）。
2.2 黑叔
当叔父结点为黑色时，需要进行旋转，以下图示了所有的旋转可能：
Case 1:

Case 2:

Case 3:

Case 4:


      可以观察到，当旋转完成后，新的旋转根全部为黑色，此时不需要再向上回溯进行平衡操作，插入操作完成。需要注意，上面四张图的“叔”、“1”、“2”、“3”结点有可能为黑哨兵结点。
      其实红黑树的插入操作不是很难，甚至比AVL树的插入操作还更简单些。红黑树的插入操作源代码如下：
[cpp] view plain copy print ?
  1. // 元素插入操作  insert_unique() 
  2. // 插入新值：节点键值不允许重复，若重复则插入无效 
  3. // 注意，返回值是个pair，第一个元素是个红黑树迭代器，指向新增节点 
  4. // 第二个元素表示插入成功与否 
  5. template<class Key , class Value , class KeyOfValue , class Compare , class Alloc> 
  6. pair<typename rb_tree<Key , Value , KeyOfValue , Compare , Alloc>::iterator , bool> 
  7. rb_tree<Key , Value , KeyOfValue , Compare , Alloc>::insert_unique(const Value &v) 
  8. { 
  9.     rb_tree_node* y = header;    // 根节点root的父节点 
  10.     rb_tree_node* x = root();    // 从根节点开始 
  11.     bool comp = true; 
  12.     while(x != 0) 
  13.     { 
  14.         y = x; 
  15.         comp = key_compare(KeyOfValue()(v) , key(x));    // v键值小于目前节点之键值？ 
  16.         x = comp ? left(x) : right(x);   // 遇“大”则往左，遇“小于或等于”则往右 
  17.     } 
  18.     // 离开while循环之后，y所指即插入点之父节点（此时的它必为叶节点） 
  19.     iterator j = iterator(y);     // 令迭代器j指向插入点之父节点y 
  20.     if(comp)     // 如果离开while循环时comp为真（表示遇“大”，将插入于左侧） 
  21.     { 
  22.         if(j == begin())    // 如果插入点之父节点为最左节点 
  23.             return pair<iterator , bool>(_insert(x , y , z) , true); 
  24.         else     // 否则（插入点之父节点不为最左节点） 
  25.             --j;   // 调整j，回头准备测试 
  26.     } 
  27.     if(key_compare(key(j.node) , KeyOfValue()(v) )) 
  28.         // 新键值不与既有节点之键值重复，于是以下执行安插操作 
  29.         return pair<iterator , bool>(_insert(x , y , z) , true); 
  30.     // 以上，x为新值插入点，y为插入点之父节点，v为新值 
  31.  
  32.     // 进行至此，表示新值一定与树中键值重复，那么就不应该插入新值 
  33.     return pair<iterator , bool>(j , false); 
  34. } 
  35.  
  36. // 真正地插入执行程序 _insert() 
  37. template<class Key , class Value , class KeyOfValue , class Compare , class Alloc> 
  38. typename<Key , Value , KeyOfValue , Compare , Alloc>::_insert(base_ptr x_ , base_ptr y_ , const Value &v) 
  39. { 
  40.     // 参数x_ 为新值插入点，参数y_为插入点之父节点，参数v为新值 
  41.     link_type x = (link_type) x_; 
  42.     link_type y = (link_type) y_; 
  43.     link_type z; 
  44.  
  45.     // key_compare 是键值大小比较准则。应该会是个function object 
  46.     if(y == header || x != 0 || key_compare(KeyOfValue()(v) , key(y) )) 
  47.     { 
  48.         z = create_node(v);    // 产生一个新节点 
  49.         left(y) = z;           // 这使得当y即为header时，leftmost() = z 
  50.         if(y == header) 
  51.         { 
  52.             root() = z; 
  53.             rightmost() = z; 
  54.         } 
  55.         else if(y == leftmost())     // 如果y为最左节点 
  56.             leftmost() = z;          // 维护leftmost()，使它永远指向最左节点 
  57.     } 
  58.     else 
  59.     { 
  60.         z = create_node(v);        // 产生一个新节点 
  61.         right(y) = z;              // 令新节点成为插入点之父节点y的右子节点 
  62.         if(y == rightmost()) 
  63.             rightmost() = z;       // 维护rightmost()，使它永远指向最右节点 
  64.     } 
  65.     parent(z) = y;      // 设定新节点的父节点 
  66.     left(z) = 0;        // 设定新节点的左子节点 
  67.     right(z) = 0;       // 设定新节点的右子节点 
  68.     // 新节点的颜色将在_rb_tree_rebalance()设定（并调整） 
  69.     _rb_tree_rebalance(z , header->parent);      // 参数一为新增节点，参数二为根节点root 
  70.     ++node_count;       // 节点数累加 
  71.     return iterator(z);  // 返回一个迭代器，指向新增节点 
  72. } 
  73.  
  74.  
  75. // 全局函数 
  76. // 重新令树形平衡（改变颜色及旋转树形） 
  77. // 参数一为新增节点，参数二为根节点root 
  78. inline void _rb_tree_rebalance(_rb_tree_node_base* x , _rb_tree_node_base*& root) 
  79. { 
  80.     x->color = _rb_tree_red;    //新节点必为红 
  81.     while(x != root && x->parent->color == _rb_tree_red)    // 父节点为红 
  82.     { 
  83.         if(x->parent == x->parent->parent->left)      // 父节点为祖父节点之左子节点 
  84.         { 
  85.             _rb_tree_node_base* y = x->parent->parent->right;    // 令y为伯父节点 
  86.             if(y && y->color == _rb_tree_red)    // 伯父节点存在，且为红 
  87.             { 
  88.                 x->parent->color = _rb_tree_black;           // 更改父节点为黑色 
  89.                 y->color = _rb_tree_black;                   // 更改伯父节点为黑色 
  90.                 x->parent->parent->color = _rb_tree_red;     // 更改祖父节点为红色 
  91.                 x = x->parent->parent; 
  92.             } 
  93.             else    // 无伯父节点，或伯父节点为黑色 
  94.             { 
  95.                 if(x == x->parent->right)   // 如果新节点为父节点之右子节点 
  96.                 { 
  97.                     x = x->parent; 
  98.                     _rb_tree_rotate_left(x , root);    // 第一个参数为左旋点 
  99.                 } 
  100.                 x->parent->color = _rb_tree_black;     // 改变颜色 
  101.                 x->parent->parent->color = _rb_tree_red; 
  102.                 _rb_tree_rotate_right(x->parent->parent , root);    // 第一个参数为右旋点 
  103.             } 
  104.         } 
  105.         else          // 父节点为祖父节点之右子节点 
  106.         { 
  107.             _rb_tree_node_base* y = x->parent->parent->left;    // 令y为伯父节点 
  108.             if(y && y->color == _rb_tree_red)    // 有伯父节点，且为红 
  109.             { 
  110.                 x->parent->color = _rb_tree_black;           // 更改父节点为黑色 
  111.                 y->color = _rb_tree_black;                   // 更改伯父节点为黑色 
  112.                 x->parent->parent->color = _rb_tree_red;     // 更改祖父节点为红色 
  113.                 x = x->parent->parent;          // 准备继续往上层检查 
  114.             } 
  115.             else    // 无伯父节点，或伯父节点为黑色 
  116.             { 
  117.                 if(x == x->parent->left)        // 如果新节点为父节点之左子节点 
  118.                 { 
  119.                     x = x->parent; 
  120.                     _rb_tree_rotate_right(x , root);    // 第一个参数为右旋点 
  121.                 } 
  122.                 x->parent->color = _rb_tree_black;     // 改变颜色 
  123.                 x->parent->parent->color = _rb_tree_red; 
  124.                 _rb_tree_rotate_left(x->parent->parent , root);    // 第一个参数为左旋点 
  125.             } 
  126.         } 
  127.     }//while 
  128.     root->color = _rb_tree_black;    // 根节点永远为黑色 
  129. } 
  130.  
  131.  
  132. // 左旋函数 
  133. inline void _rb_tree_rotate_left(_rb_tree_node_base* x , _rb_tree_node_base*& root) 
  134. { 
  135.     // x 为旋转点 
  136.     _rb_tree_node_base* y = x->right;          // 令y为旋转点的右子节点 
  137.     x->right = y->left; 
  138.     if(y->left != 0) 
  139.         y->left->parent = x;           // 别忘了回马枪设定父节点 
  140.     y->parent = x->parent; 
  141.  
  142.     // 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来） 
  143.     if(x == root)    // x为根节点 
  144.         root = y; 
  145.     else if(x == x->parent->left)         // x为其父节点的左子节点 
  146.         x->parent->left = y; 
  147.     else                                  // x为其父节点的右子节点 
  148.         x->parent->right = y; 
  149.     y->left = x; 
  150.     x->parent = y; 
  151. } 
  152.  
  153.  
  154. // 右旋函数 
  155. inline void _rb_tree_rotate_right(_rb_tree_node_base* x , _rb_tree_node_base*& root) 
  156. { 
  157.     // x 为旋转点 
  158.     _rb_tree_node_base* y = x->left;          // 令y为旋转点的左子节点 
  159.     x->left = y->right; 
  160.     if(y->right != 0) 
  161.         y->right->parent = x;           // 别忘了回马枪设定父节点 
  162.     y->parent = x->parent; 
  163.  
  164.     // 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来） 
  165.     if(x == root) 
  166.         root = y; 
  167.     else if(x == x->parent->right)         // x为其父节点的右子节点 
  168.         x->parent->right = y; 
  169.     else                                  // x为其父节点的左子节点 
  170.         x->parent->left = y; 
  171.     y->right = x; 
  172.     x->parent = y; 
  173. }  
// 元素插入操作  insert_unique()
// 插入新值：节点键值不允许重复，若重复则插入无效
// 注意，返回值是个pair，第一个元素是个红黑树迭代器，指向新增节点
// 第二个元素表示插入成功与否
template<class Key , class Value , class KeyOfValue , class Compare , class Alloc>
pair<typename rb_tree<Key , Value , KeyOfValue , Compare , Alloc>::iterator , bool>
rb_tree<Key , Value , KeyOfValue , Compare , Alloc>::insert_unique(const Value &v)
{
	rb_tree_node* y = header;    // 根节点root的父节点
	rb_tree_node* x = root();    // 从根节点开始
	bool comp = true;
	while(x != 0)
	{
		y = x;
		comp = key_compare(KeyOfValue()(v) , key(x));    // v键值小于目前节点之键值？
		x = comp ? left(x) : right(x);   // 遇“大”则往左，遇“小于或等于”则往右
	}
	// 离开while循环之后，y所指即插入点之父节点（此时的它必为叶节点）
	iterator j = iterator(y);     // 令迭代器j指向插入点之父节点y
	if(comp)     // 如果离开while循环时comp为真（表示遇“大”，将插入于左侧）
	{
		if(j == begin())    // 如果插入点之父节点为最左节点
			return pair<iterator , bool>(_insert(x , y , z) , true);
		else     // 否则（插入点之父节点不为最左节点）
			--j;   // 调整j，回头准备测试
	}
	if(key_compare(key(j.node) , KeyOfValue()(v) ))
		// 新键值不与既有节点之键值重复，于是以下执行安插操作
		return pair<iterator , bool>(_insert(x , y , z) , true);
	// 以上，x为新值插入点，y为插入点之父节点，v为新值

	// 进行至此，表示新值一定与树中键值重复，那么就不应该插入新值
	return pair<iterator , bool>(j , false);
}

// 真正地插入执行程序 _insert()
template<class Key , class Value , class KeyOfValue , class Compare , class Alloc>
typename<Key , Value , KeyOfValue , Compare , Alloc>::_insert(base_ptr x_ , base_ptr y_ , const Value &v)
{
	// 参数x_ 为新值插入点，参数y_为插入点之父节点，参数v为新值
	link_type x = (link_type) x_;
	link_type y = (link_type) y_;
	link_type z;

	// key_compare 是键值大小比较准则。应该会是个function object
	if(y == header || x != 0 || key_compare(KeyOfValue()(v) , key(y) ))
	{
		z = create_node(v);    // 产生一个新节点
		left(y) = z;           // 这使得当y即为header时，leftmost() = z
		if(y == header)
		{
			root() = z;
			rightmost() = z;
		}
		else if(y == leftmost())     // 如果y为最左节点
			leftmost() = z;          // 维护leftmost()，使它永远指向最左节点
	}
	else
	{
		z = create_node(v);        // 产生一个新节点
		right(y) = z;              // 令新节点成为插入点之父节点y的右子节点
		if(y == rightmost())
			rightmost() = z;       // 维护rightmost()，使它永远指向最右节点
	}
	parent(z) = y;      // 设定新节点的父节点
	left(z) = 0;        // 设定新节点的左子节点
	right(z) = 0;       // 设定新节点的右子节点
	// 新节点的颜色将在_rb_tree_rebalance()设定（并调整）
	_rb_tree_rebalance(z , header->parent);      // 参数一为新增节点，参数二为根节点root
	++node_count;       // 节点数累加
	return iterator(z);  // 返回一个迭代器，指向新增节点
}


// 全局函数
// 重新令树形平衡（改变颜色及旋转树形）
// 参数一为新增节点，参数二为根节点root
inline void _rb_tree_rebalance(_rb_tree_node_base* x , _rb_tree_node_base*& root)
{
	x->color = _rb_tree_red;    //新节点必为红
	while(x != root && x->parent->color == _rb_tree_red)    // 父节点为红
	{
		if(x->parent == x->parent->parent->left)      // 父节点为祖父节点之左子节点
		{
			_rb_tree_node_base* y = x->parent->parent->right;    // 令y为伯父节点
			if(y && y->color == _rb_tree_red)    // 伯父节点存在，且为红
			{
				x->parent->color = _rb_tree_black;           // 更改父节点为黑色
				y->color = _rb_tree_black;                   // 更改伯父节点为黑色
				x->parent->parent->color = _rb_tree_red;     // 更改祖父节点为红色
				x = x->parent->parent;
			}
			else    // 无伯父节点，或伯父节点为黑色
			{
				if(x == x->parent->right)   // 如果新节点为父节点之右子节点
				{
					x = x->parent;
					_rb_tree_rotate_left(x , root);    // 第一个参数为左旋点
				}
				x->parent->color = _rb_tree_black;     // 改变颜色
				x->parent->parent->color = _rb_tree_red;
				_rb_tree_rotate_right(x->parent->parent , root);    // 第一个参数为右旋点
			}
		}
		else          // 父节点为祖父节点之右子节点
		{
			_rb_tree_node_base* y = x->parent->parent->left;    // 令y为伯父节点
			if(y && y->color == _rb_tree_red)    // 有伯父节点，且为红
			{
				x->parent->color = _rb_tree_black;           // 更改父节点为黑色
				y->color = _rb_tree_black;                   // 更改伯父节点为黑色
				x->parent->parent->color = _rb_tree_red;     // 更改祖父节点为红色
				x = x->parent->parent;          // 准备继续往上层检查
			}
			else    // 无伯父节点，或伯父节点为黑色
			{
				if(x == x->parent->left)        // 如果新节点为父节点之左子节点
				{
					x = x->parent;
					_rb_tree_rotate_right(x , root);    // 第一个参数为右旋点
				}
				x->parent->color = _rb_tree_black;     // 改变颜色
				x->parent->parent->color = _rb_tree_red;
				_rb_tree_rotate_left(x->parent->parent , root);    // 第一个参数为左旋点
			}
		}
	}//while
	root->color = _rb_tree_black;    // 根节点永远为黑色
}


// 左旋函数
inline void _rb_tree_rotate_left(_rb_tree_node_base* x , _rb_tree_node_base*& root)
{
	// x 为旋转点
	_rb_tree_node_base* y = x->right;          // 令y为旋转点的右子节点
	x->right = y->left;
	if(y->left != 0)
		y->left->parent = x;           // 别忘了回马枪设定父节点
	y->parent = x->parent;

	// 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来）
	if(x == root)    // x为根节点
		root = y;
	else if(x == x->parent->left)         // x为其父节点的左子节点
		x->parent->left = y;
	else                                  // x为其父节点的右子节点
		x->parent->right = y;
	y->left = x;
	x->parent = y;
}


// 右旋函数
inline void _rb_tree_rotate_right(_rb_tree_node_base* x , _rb_tree_node_base*& root)
{
	// x 为旋转点
	_rb_tree_node_base* y = x->left;          // 令y为旋转点的左子节点
	x->left = y->right;
	if(y->right != 0)
		y->right->parent = x;           // 别忘了回马枪设定父节点
	y->parent = x->parent;

	// 令y完全顶替x的地位（必须将x对其父节点的关系完全接收过来）
	if(x == root)
		root = y;
	else if(x == x->parent->right)         // x为其父节点的右子节点
		x->parent->right = y;
	else                                  // x为其父节点的左子节点
		x->parent->left = y;
	y->right = x;
	x->parent = y;
}
红黑树精通指南：面试、实战与源码分析
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
05-12 177万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
红黑树-原理详解
架构师之路。。
01-27 1908
红黑树之原理详解 R-B Tree简介 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。 红黑树的特性: （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！] （4）如果一个节点是红色的，则它的子节点必须是黑色的。 （5）从一个节点到该节点的子孙节点的所有路径上包含相同
【数据结构】红黑树超详解 ---一篇通关红黑树原理（含源码解析+动态构建红黑树）
2402_84949062的博客
04-11 6378
【数据结构】红黑树超详解 ---一篇通关红黑树底层原理（含源码解析+动态构建红黑树）
红黑树的实现原理和应用场景
lssffy的博客
04-01 1218
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它通过特定的规则确保树在插入和删除操作后能保持相对平衡，从而保证查找、插入、删除等操作的时间复杂度为O(log n)。红黑树是一种高效的自平衡二叉查找树，通过精心设计的平衡规则和旋转操作，在各种动态数据管理场景中表现出色。虽然实现相对复杂，但其优秀的综合性能使其成为许多高级数据结构和系统组件的首选实现方式。理解红黑树的原理和实现，对于深入掌握计算机科学中的数据结构和算法设计具有重要意义。
C++ STL源码剖析之红黑树
白话机器学习
07-21 242
根据上述插入过程与源码分析，我们得出下面三种： 假设P代码父亲节点，N代表当前新插入节点，U代表叔叔节点，G代表祖父节点。case 1:U为红色，P、N也都为红色，则可以通过改变颜色，自底向上递归调整，下次N就变味G，往上判断即可。如果碰巧将根节点染成了红色, 可以在算法的最后强制root改为黑。case 2:U为黑色，考虑N是P的左孩子还是右孩子。case2.1 如果是右孩子,先进行左旋转，再进入下一种情况。case2.2 可能是上述情况变化而来，但不一定是！策略为：右旋转，改变颜色。
STL源码剖析---红黑树原理详解下
热门推荐
Hackbuteer1的专栏
07-18 2万+
算法导论书上给出的红黑树的性质如下，跟STL源码剖析书上面的4条性质大同小异。       1、每个结点或是红色的，或是黑色的       2、根节点是黑色的       3、每个叶结点（NIL）是黑色的       4、如果一个节点是红色的，则它的两个儿子都是黑色的。       5、对于每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑色结点。       从红黑树上删除一
STL源码剖析---关联式容器map详解
Ferlan的博客
01-16 758
STL源码剖析---关联式容器map什么是mapmap中存储的键值对map的迭代器map的常用操作总结 什么是map map是STL中关联式容器的一种，所谓关联式容器，元素是按关键字来保存和访 问的，而序列式容器中的元素则是按它们在容器中的位置来顺序保存和访问的。 本片博客的主角map中，存储的不是一般的数据，而是一个个的键值对，我们称 之为pair，pair键值对由两部分组成：键值key和实值v...
STL源码剖析简体中文完整版(带目录)
08-17
根据提供的文件信息，“STL源码剖析简体中文完整版(带目录)”这一标题与描述表明这是一份针对STL（Standard Template Library，标准模板库）的深入分析文档，主要面向的是希望深入了解STL内部实现原理及代码结构的...
透彻了解红黑树之三
小博客
03-06 2349
//一、左旋代码分析 /*----------------------------------------------------------- | node right | / / ==> / / | a right node y | / / / / | b y
源码剖析：STL中红黑树（RB-tree）
weixin_67035108的博客
08-09 1016
本文深入解析红黑树(RB-tree)的实现原理与数据结构设计。首先介绍红黑树的五大规则：根黑、不红红、黑路同等特性，并分析了插入节点时的三种情况（根节点、红叔叔、黑叔叔）及对应的旋转操作。对删除操作也分情况讨论，包括单子节点和无子节点场景。详细阐述了红黑树的节点结构设计、迭代器实现（双向迭代器），以及底层数据结构成员定义。最后探讨了红黑树的构造方式（空树/复制）和关键操作：insert_unique（不重复插入）、insert_equal（允许重复）和find查找方法
STL源码剖析---红黑树原理详解
flyingleo1981的专栏
07-27 4921
一、红黑树概述      红黑树和我们以前学过的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。不过自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。这一点在我们了解了红黑树的实现原理后，就会有更加深切的体会。      红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL
stl源码剖析09——RB-Tree(红黑树)
www_dong的博客
02-25 1033
一、红黑树定义 红黑树（RB-tree）也是广泛应用的平衡二叉树 红黑树必须满足下面的规则： 1.每个节点不是红色就是黑色 2.根节点为黑色 3.如果节点为红色，那么子节点必须为黑（也就是说不能有两个节点连续为红色） 4.任一节点到NULL（树尾端）的任何路径上，所含的黑色节点数目必须相同 下图是一个图示。深色的为黑色，浅色的为红色 二、插入节点 新插入的节点必为红色 如果插入前树非空，插入的新节点为黑色，肯定不满足上面的规则4 如果插入前树非空，插入的新节点为红色，那么
STL源码分析之红黑树
sydney__的博客
01-08 246
主要分析一下STL里的红黑树，红黑树相对来说是一种较为复杂的数据结构，具体的学习方法建议看那种带有很多图解的博客，先理解其原理流程，再自己写下代码，其实就能理解了。STL里红黑树的实现有几个特点，一个它设置了一个空头结点header，它的左节点指向树最小元素，有节点指向树最大元素，实际带有有意义值的头结点为root,root的父节点为header.这使在一些插入删除操作时要讨论下特殊情况，附上代码...
STL源码剖析 关联式容器 红黑树
CHYabc123456hh的博客
11-24 1175
概念 红黑树不仅仅是一个二叉树，必须满足如下条件 1，每个节点不是红色就是黑色 (深色底纹为黑色，浅色底纹为红色) 2，根节点是黑色的 3，如果节点为红，其子节点必须为黑色的 4，任一节点至NULL(树的尾端)的任何路径，所含的黑节点的数量必须相同 插入节点 分别插入 3 8 35 75 ，他们均破坏了红黑树的规则，需要调整树形，两种方式(修改颜色 或 旋转) 产生不平衡的状态，即高度相差1以上。这没关系，因为RB-Tree是一种弱平衡性，他是按照颜色进行高度的限定，保证在弱平衡..
红黑树的经典介绍
坚持
04-21 1117
目录 1 红黑树的介绍 2 红黑树的应用 3 红黑树的时间复杂度和相关证明 4 红黑树的基本操作(一) 左旋和右旋 5 红黑树的基本操作(二) 添加 6 红黑树的基本操作(三) 删除        作者：Sky Wang    于 2013-08-08                                概述：R-B Tree，又称为“红黑树”。本文参考
红黑树原理
qq_37254296的博客
08-12 250
红黑树（B-R Tree）：全称 Red-Black Tree,是一种特殊的二叉查找树。红黑树的上每个节点都有存储位表示节点的颜色，可以是红（Red）或 黑（Black） 红黑树的特性 每个节点要么是黑色，要么是红色； 跟节点是黑色； 每个叶子节点(NIL)是黑色； 如果一个节点是红色，那么它的子节点必须是黑色； 从一个节点到该节点的子孙节点的所有路径，其包含的黑色节点的树相同。 注意： ...
// 3. 红黑树结构体 typedef struct rb_tree { rb_tree_node *root_node; // 指向根节点（树的起点） rb_tree_node *nil_node; // 哨兵节点（代表空节点/叶子节点） }rb_tree; /* 整棵树包含根节点和统一的哨兵节点（所有叶子节点都指向它）*/ 解释一遍这个：/* 整棵树包含根节点和统一的哨兵节点（所有叶子节点都指向它）*/
最新发布
07-01
<think>首先，用户的问题是：“我想理解红黑树结构中哨兵节点的作用及实现原理请问红黑树中统一的哨兵节点是什么作用，为什么所有叶子节点都指向它” 根据系统级指令：-所有行内数学表达式必须使用$...$格式。-独立公式必须使用$$...$$格式并单独成段。 -LaTeX语法正确。-使用中文回答。-生成相关问题。 -在回答中引用的段落末尾自然地添加引用标识，例如[^1]。用户可见层：-回答结构清晰，帮助用户逐步解决问题。 -尽量保证回答真实可靠。 参考站内引用：-引用[1]、[2]、[3]、[4]、[5]提供了关于红黑树的信息，特别是哨兵节点的作用。关键点从引用中提取： -引用[1]：提到节点只能是黑或红，根节点与叶子节点必须是黑色（叶子节点指nullptr）。 -引用[2]：每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的。 -引用[3]：每个叶节点(nil)是黑色的。-引用[4]：叶子节点为黑色。-引用[5]：在实现中，有一个哨兵节点NIL，用于表示叶子节点。用户的问题焦点是哨兵节点的作用和为什么所有叶子节点都指向它。 结构化回答：1.**介绍哨兵节点**：解释什么是哨兵节点。2.**作用**：详细说明哨兵节点的作用。 3. **实现原理**：描述如何实现。4.**为什么所有叶子节点都指向它**：解释原因。 5. **添加引用标识**：在相关部分末尾添加引用。 生成相关问题：在回答末尾，添加相关问题。 使用中文回答。 步骤： -开头简要介绍红黑树和哨兵节点。 -然后逐步解释。-确保使用正确的LaTeX格式（如果有数学表达式）。-结尾生成相关问题。内容大纲： 1. **什么是哨兵节点？**：在红黑树中，哨兵节点（通常称为NIL节点）是一个特殊的节点，用于表示所有叶子节点。它不是存储实际数据的节点，而是作为一个占位符。-引用[2]和[3]提到叶结点是NIL指针或NULL结点。2. **作用**：- **简化实现**：避免处理空指针，统一处理边界条件。- **维护红黑树性质**：确保所有叶子节点都是黑色的，满足红黑树的性质（如引用[1]、[2]、[3]所述）。-**减少条件检查**：在插入和删除操作中，减少对空指针的特殊处理。-引用[5]中显示实现中使用哨兵节点。3.**为什么所有叶子节点都指向它？**-在红黑树中，每个叶子节点（即没有子节点的节点）都指向同一个哨兵节点NIL。这是因为：-统一性：通过一个共享的NIL节点，确保所有叶子节点在逻辑上一致。-节省空间：避免为每个叶子节点创建单独的NIL节点，节省内存。-简化操作：在遍历和平衡操作中，可以统一处理NIL节点。-引用[3]提到“每个叶节点(nil)是黑色的”，并指向同一个节点。 4. **实现原理**：-在代码中，定义一个哨兵节点实例，通常是黑色（如引用[5]所示）。-所有叶子节点的左子节点和右子节点都指向这个NIL节点。-在插入和删除时，新节点初始化为指向NIL。 5. **总结**：重申重要性。 添加引用：-在解释作用时，引用[2]、[3]。-在实现时，引用[5]。 生成相关问题：-例如：1.红黑树中哨兵节点如何影响插入操作？2.不使用哨兵节点会有什么问题？3.红黑树的其他性质如何通过哨兵节点维护？ 确保回答清晰、真实可靠。</think>### 红黑树中哨兵节点的作用及实现原理 红黑树是一种自平衡二叉搜索树，其核心特性通过严格的规则（如节点颜色、路径平衡）确保操作高效性。在实现中，哨兵节点（也称为NIL节点）是一个关键设计，用于统一表示所有叶子节点。下面我将逐步解释其作用和实现原理，确保回答基于可靠的技术细节。 #### 1. **什么是哨兵节点？** - 哨兵节点是一个特殊的“虚拟”节点，不存储实际数据，仅作为红黑树中所有叶子节点的统一占位符。在代码实现中，它通常被定义为一个共享的、颜色为黑色的单例对象（如`NIL`）。例如： - 所有实际叶子节点（即无子节点的节点）的左子指针和右子指针都指向这个唯一的哨兵节点。 - 根节点的父指针也可能指向哨兵节点（当树为空时）。 - 这避免了直接使用`nullptr`或`NULL`，简化了边界处理[^2][^3]。 #### 2. **哨兵节点的作用** - **维护红黑树性质**：红黑树有五大规则（如根节点为黑、不能有连续红节点、每条路径黑色节点数相同）。哨兵节点确保所有叶子节点“逻辑上”为黑色，满足性质： - 规则要求“每个叶结点必须是黑色的”（引用[2]），哨兵节点本身定义为黑色，统一了叶子节点的颜色属性。 - 例如，在插入新节点时，新节点的子节点自动指向哨兵节点，避免了颜色冲突。 - **简化算法实现**： - 在插入或删除操作中，哨兵节点作为边界哨兵，减少了对空指针的额外检查。例如，旋转或颜色调整时，无需特殊处理`null`，直接操作哨兵节点即可。 - 这提高了代码健壮性，降低了错误概率（如空指针解引用）。 - **节省内存和提升性能**： - 所有叶子节点共享同一个哨兵节点实例，避免了为每个叶子创建独立对象，节省内存开销。 - 在遍历（如中序遍历）时，哨兵节点作为终止标志，统一了递归或迭代的逻辑。 - 这些作用确保了红黑树的自平衡效率，尤其在动态数据场景（如C++ STL的`map`）中至关重要[^4][^5]。 #### 3. **为什么所有叶子节点都指向同一个哨兵节点？** - **统一性与一致性**：红黑树的性质依赖于路径上黑色节点的数量统计。如果每个叶子节点使用独立的`nullptr`，会导致： - 路径长度计算不一致（`nullptr`无法携带颜色信息）。 - 在插入/删除时需额外逻辑处理边界，破坏规则（如引用[3]所述“对每个节点，从该节点到其后代叶节点的简单路径上，均包含相同数目的黑色节点”）。 - **实现便捷性**：通过共享哨兵节点： - 所有叶子节点在逻辑上等价，简化了性质验证（例如，计算黑色高度时，哨兵节点直接贡献一个“黑色计数”）。 - 在代码中，初始化时只需创建一个哨兵实例（如`NIL`），并在构造新节点时将其子指针指向它。 - **避免错误**：直接使用`nullptr`可能导致： - 颜色规则失效（`nullptr`无法着色）。 - 旋转操作中边界条件复杂化，易引发崩溃或失衡。 - 因此，统一指向哨兵节点是平衡性能与正确性的最优设计[^1][^5]。 #### 4. **实现原理** - **定义哨兵节点**：在代码中，哨兵节点通常作为类的静态成员或全局常量，颜色固定为黑色，无数据字段。例如Java实现： ```java class RedBlackNode<T> { T data; RedBlackNode<T> left, right, parent; Color color; // 枚举: RED 或 BLACK } class RedBlackTree<T extends Comparable<T>> { private RedBlackNode<T> root; private final RedBlackNode<T> NIL = new RedBlackNode<>(null); // 哨兵节点 public RedBlackTree() { NIL.color = Color.BLACK; // 设置为黑色 root = NIL; // 空树时根指向哨兵 } } ``` - 这里`NIL`是共享的，所有新节点的`left`和`right`初始化为`NIL`[^5]。 - **操作中的使用**： - **插入**：新节点插入时，其子节点默认为`NIL`。调整平衡（旋转或变色）时，若遇到`NIL`，直接视为黑色节点处理。 - **删除**：当节点被删除后，其位置由`NIL`替代，确保树结构完整。 - **遍历**：递归终止条件为节点等于`NIL`。 - 这种设计严格遵循红黑树性质，并通过哨兵节点隐含了“叶子均为黑”的约束[^4]。 #### 总结 哨兵节点在红黑树中充当“统一边界卫士”，通过共享实例确保所有叶子节点逻辑一致（黑色），简化了算法实现并维护了平衡性。其核心价值在于消除`nullptr`的不确定性，使插入、删除等操作高效可靠。在工程实践中（如C++ STL或Java TreeMap），哨兵节点是红黑树稳定性的基石[^4][^5]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值