红黑树从入门到进阶：4 条规则如何筑牢 O (logN) 效率根基？

草莓熊Lotso2025-11-26 8:46


🔥草莓熊Lotso： 个人主页
❄️个人专栏: 《C++知识分享》 《Linux 入门到实践：零基础也能懂》
✨生活是默默的坚持，毅力是永久的享受！

🎬 博主简介：

文章目录

  • 前言：
  • [一. 红黑树核心概念：4 条规则定平衡](#一. 红黑树核心概念：4 条规则定平衡)
    • [1.1 红黑树的核心规则](#1.1 红黑树的核心规则)
    • [1.2 关键问题思考：4 条规则如何保证最长路径≤2× 最短路径？](#1.2 关键问题思考：4 条规则如何保证最长路径≤2× 最短路径？)
  • [二. 红黑树结构设计：节点与类定义](#二. 红黑树结构设计：节点与类定义)
  • [三. 红黑树插入：分场景维护平衡](#三. 红黑树插入：分场景维护平衡)
    • [3.1 插入前的关键约定](#3.1 插入前的关键约定)
    • [3.2 平衡修复场景分析](#3.2 平衡修复场景分析)
      • [3.2.1 场景 1：叔叔（u）存在且为红色 --> 仅变色](#3.2.1 场景 1：叔叔（u）存在且为红色 --> 仅变色)
      • [3.2.2 场景 2：叔叔（u）不存在或为黑色 单旋 --> 变色](#3.2.2 场景 2：叔叔（u）不存在或为黑色 单旋 --> 变色)
      • [3.2.3 场景3：叔叔（u）不存在或为黑色 → 双旋 + 变色](#3.2.3 场景3：叔叔（u）不存在或为黑色 → 双旋 + 变色)
    • [3.3 插入完整代码实现](#3.3 插入完整代码实现)
  • [四. 红黑树查找与平衡验证](#四. 红黑树查找与平衡验证)
    • [4.1 查找：复用二叉搜索树逻辑](#4.1 查找：复用二叉搜索树逻辑)
    • [4.2 平衡验证：检查 4 条规则](#4.2 平衡验证：检查 4 条规则)
  • 结尾：

前言：

红黑树用 4 条颜色规则实现 "近似平衡" ，既避免了 AVL 树的频繁旋转，又将效率稳定在 O (logN)，成为 STL、内核等场景的 "首选树结构"。但规则背后的平衡逻辑、插入时的变色与旋转组合，常让人困惑。本文从规则本质出发，拆解插入全场景，帮你理清红黑树如何用简单约束撑起高效性能。

一. 红黑树核心概念：4 条规则定平衡

1.1 红黑树的核心规则

红黑树本质是带颜色标记的二叉搜索树，每个节点只有 "红" 或 "黑" 两种颜色，通过以下 4 条规则确保近似平衡：

  1. 每个结点不是红色就是黑色
  2. 根结点是黑色的
  3. 如果一个结点是红色的，则它的两个孩子结点必须是黑色的，也就是说任意一条路径不会有连续的红色结点。
  4. 对于任意一个结点，从该结点到其所有NULL结点的简单路径上，均包含相同数量的黑色结点。

说明 ：《算法导论》等书籍上补充了一条每个叶子结点(NIL)都是黑色的规则。他这里所指的叶子结点不是传统意义上的叶子结点，而是我们说的空结点，有些书籍上也把NIL叫做外部结点。NIL是为了方便准确的标识出所有路径，《算法导论》在后续讲解的实现的细节中也忽略了NIL结点，所以我们知道一下这个概念即可。

规则编号 规则内容 核心作用与逻辑后果
1 每个节点非红即黑。 基础定义：颜色是用于平衡控制的"工具"，为后续规则提供基础。
2 根节点必须是黑色。 统一起点：保证从根出发的所有路径都有一个共同的黑色起点，简化边界情况处理。
3 红色节点的两个子节点必须是黑色。（即：不能有两个连续的红色节点） 限制路径：此规则确保了从根到叶子的最长路径，不会超过最短路径的2倍。这是控制"平衡度"的关键。
4 对于任意节点，从其出发到达所有可达的空叶子节点（NIL）的路径上，包含相同数量的黑色节点。（称为"黑色高度"） 确保平衡：这是红黑树平衡的核心。它保证了最长的路径（红黑交替）和最短的路径（全黑）之间的差值被限制在路径长度以内，从而维持了近似平衡。
衍生特性 新插入的节点默认为红色。 最小化破坏：插入红节点不会违反规则4（黑色高度不变），只会可能违反规则3（产生连续红节点）。这减少了需要调整的情况，使修复更简单。

1.2 关键问题思考：4 条规则如何保证最长路径≤2× 最短路径？

  • 由规则 4 可知：所有路径的黑色节点数量相同（记为bh），因此极端场景下最短路径是全黑节点路径（长度 = bh）；
  • 由规则 2 和 3 可知：路径中无连续红色节点，因此最长路径是 "黑 - 红" 交替路径（长度 = 2×bh）；
  • 综上 ：任意路径长度满足 bh ≤ 路径长度 ≤ 2×bh，即最长路径不超过最短路径的 2 倍。

红黑树的效率问题 ：

结合二叉搜索树的特性，可推出红黑树节点数 N 与最短路径 bh 的关系：2^bh -1 ≤ N < 2^(2bh) -1 ，进一步可得bh ≈ logN，也就是意味着红黑色增删查改最坏也就是走最长路径，因此红黑树的最坏时间复杂度仍为 O (logN)。

红黑树的表达相对AVL树要抽象一些，AVL树通过高度差直观的控制了平衡，红黑树通过4条规则的颜色约束，间接实现了近似平衡，他们效率都是同一档次，但是相对而言，插入相同数量的结点，红黑树的旋转次数是更少的，因为他对平衡的控制没那么严格。


二. 红黑树结构设计：节点与类定义

红黑树的节点需存储键值对、左右子指针、父指针 （用于回溯平衡）和 颜色标记，类定义如下:

cpp 复制代码 
#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

// 枚举结点颜色
enum Colour
{
	Red,  // 红色结点
	Black // 黑色结点
};

// 红黑树结构
template<class K,class V>
struct RBTreeNode
{
	pair<K, V> _kv;				// 存储键值对（Key-Value）
	RBTreeNode<K, V>* _parent;  // 左子节点指针
	RBTreeNode<K, V>* _left;    // 右子节点指针
	RBTreeNode<K, V>* _right;   // 父节点指针（回溯平衡需用到）
	Colour _col;				// 节点颜色

	RBTreeNode(const pair<K, V>& kv)
		:_parent(nullptr)
		, _left(nullptr)
		, _right(nullptr)
		,_kv(kv)
		, _col(Red) // 非空树插入时设为红色，避免破坏规则4
	{}
};

// 红黑树类
template <class K, class V>
class RBTree {
    typedef RBTreeNode<K, V> Node;  // 简化节点类型名
public:
    // 核心接口：插入、查找、平衡验证
    bool Insert(const pair<K, V>& kv);
    Node* Find(const K& key);
    bool IsBalance();

private:
    // 辅助接口：旋转（与AVL树逻辑一致，无需更新平衡因子）
    void RotateR(Node* parent);  // 右单旋
    void RotateL(Node* parent);  // 左单旋
    // 平衡验证的递归辅助函数
    bool Check(Node* root, int blackNum, const int refNum);

private:
    Node* _root = nullptr;  // 根节点，默认空树
};

三. 红黑树插入：分场景维护平衡

红黑树的插入流程分为两步：按二叉搜索树规则插入节点 → 根据颜色规则修复平衡。其中，平衡修复是核心，需根据 "父亲节点颜色" 和 "叔叔节点颜色" 分场景处理。

3.1 插入前的关键约定

  • 插入一个值按二叉搜索树规则进行插入， 插入后我们只需要观察是否符合红黑树的4条规则。
  • 如果是空树插入，新增结点是黑色结点。如果是非空树插入，新增结点必须是红色结点，因为非空树插入，新增黑色结点就破坏了规则4，规则4是很难维护的。
  • 非空树插入后，新增结点必须是红色结点，如果其 父亲结点是黑色 的，则没违反任何规则，插入结束。
  • 非空树插入后，新增结点必须是红色结点，如果其 父亲结点是红色 的，则违反规则 。进一步分析，c是红色，p为红，g必为黑，这三个颜色固定了 ，关键的变化看u的情况，需要根据u分为3种不同场景分别处理。

说明 ：下面所有的讲解和图中我们都把新增结点标识为 c(cur)，c的父亲标识为 p(parent)，p的父亲标识为 g(grandparent)，p的兄弟标识为 u(uncle)。

3.2 平衡修复场景分析

3.2.1 场景 1：叔叔（u）存在且为红色 --> 仅变色

  • 条件 ：c（当前节点）红 、p（父）红 、g（祖父）黑 、u（叔叔）红
  • 分析：因为p和u都是红色，g是黑色，把p和u变黑，左边子树路径各增加一个黑色结点，g再变红，相当于保持g所在的子树的黑色结点数量不变，同时解决了c和p连续红色结点的问题，需要继续往上更新是因为，g是红色，如果g的父亲还是红色，那么就还需要继续处理，如果g的父亲是黑色，则处理结束了；如果g就是整树的根，再把g变回黑色。
  • 处理逻辑 ：
    • 将p和u设为黑色（解决连续红色问题）；
    • 将g设为红色（保持黑色节点数量不变，符合规则 4）；
    • 将g作为新的c，更新c的p继续向上回溯（若g的父亲也是红色，需重复处理）；
  • 核心原理：通过变色维持 "黑色节点数量守恒"，同时消除连续红色节点。
  • 注意：场景1只变色，不旋转。所以无论是c在p的左还是右，p是g的左还是右，都是上面的变色处理方式。
  • 跟ALV树类似，上图中我们展现了一种具体情况，但是实际中需要这样处理的有很多种情况。
  • 图1将以上类似的处理进行了抽象表达，d/e/f代表每条路径拥有hb个黑色结点的子树，a/b代表每条路径拥有hb-1个黑色结点的根为红的子树，hb>=0。
  • 图2/图3/图4，分别展现了hb == 0 / hb == 1/ hb == 2的具体情况组合分析，当hb等于2时，这里组合情况上百亿种，这些样例是帮助我们理解，不论情况多少种，多么复杂，处理方式一样的，变色再继续往上处理即可，所以我们只需要看抽象图即可。

3.2.2 场景 2：叔叔（u）不存在或为黑色 单旋 --> 变色

  • 条件 ：c红、p红、g黑、u不存在/黑 ，且c与p在同一侧 （p是g的左孩子，c是p的左孩子；或p是g的右孩子，c是p的右孩子）；
  • 分析：p必须变黑，才能解决连续红色结点的问题，u不存在或者是黑色的，这里单纯的变色无法解决，需要旋转 + 变色
  • 处理逻辑（以p是g的左孩子为例） ：
    • 以g为旋转点进行右单旋；
    • 将p设为黑色（新的子树根，避免连续红色）；
    • 将g设为红色；
  • 核心原理 ：通过旋转调整节点位置，再通过变色消除连续红色，且无需继续向上回溯（p变黑后，与g的父亲不会违规）。

3.2.3 场景3：叔叔（u）不存在或为黑色 → 双旋 + 变色

  • 条件 ：c红、p红、g黑、u不存在/黑 ，且c与p在异侧 （p是g的左孩子，c是p的右孩子；或p是g的右孩子，c是p的左孩子）；
  • 分析：p必须变黑，才能解决，连续红色结点的问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要旋转+变色
  • 处理逻辑（以p是g的左孩子为例） ：
    • 以p为旋转点进行左单旋（将c转到p的位置，变为场景 2 的形态）；
    • 以g为旋转点进行右单旋；
    • 将c设为黑色（新的子树根）；
    • 将g设为红色；
  • 核心原理：先通过一次旋转将 "异侧" 转为 "同侧"，再按场景 2 处理，最终消除违规。

3.3 插入完整代码实现

cpp 复制代码 
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = Black;
			return true;
		}
		
		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		cur->_col = Red;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == Red)
		{
			Node* grandparent = parent->_parent;
			if (grandparent->_left == parent)
			{
				Node* uncle = grandparent->_right;
				// uncle存在且为红色
				if (uncle && uncle->_col == Red)
				{
					// 变色+继续向上处理
					parent->_col = Black;
					uncle->_col = Black;
					grandparent->_col = Red;

					cur = grandparent;
					parent = cur->_parent;
				}
				else //uncle不存在或者存在且为黑色 
				{
					if (cur == parent->_left) // 单旋+变色
					{
						//   g
						// p   u
						//c
						RotateR(grandparent);
						parent->_col = Black;
						grandparent->_col = Red;
					}
					else // 双旋+变色
					{
						//   g
						// p   u
						//  c
						RotateL(parent);
						RotateR(grandparent);

						cur->_col = Black;
						grandparent->_col = Red;
					}
					break;
				}
			}

			else
			{
				Node* uncle = grandparent->_left;
				if (uncle && uncle->_col == Red)
				{
					// 变色+继续向上处理
					uncle->_col = Black;
					parent->_col = Black;
					grandparent->_col = Red;

					cur = grandparent;
					parent = cur->_parent;
				}
				else
				{
					if (parent->_right == cur) // 单旋+变色
					{
						//   g
						// u   p
						//      c
						RotateL(grandparent);

						parent->_col = Black;
						grandparent->_col = Red;
					}
					else // 双旋+变色
					{
						//   g
						// u   p
						//   c

						RotateR(parent);
						RotateL(grandparent);

						cur->_col = Black;
						grandparent->_col = Red;
					}

					break;
				}
			}
		}
		// 确保根节点始终为黑色（防止回溯时根被设为红色）
		_root->_col = Black;

		return true;
	}
private:
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

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

		Node* grandparent = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;

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

			subL->_parent = grandparent;
		}
	}

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

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

		Node* grandparent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

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

			subR->_parent = grandparent;
		}
	}

四. 红黑树查找与平衡验证

4.1 查找：复用二叉搜索树逻辑

红黑树的查找与普通二叉搜索树一致，时间复杂度 O (logN)：

cpp 复制代码 
Node* Find(const K& key) {
    Node* cur = _root;
    while (cur) {
        if (cur->_kv.first < key) {
            cur = cur->_right;
        } else if (cur->_kv.first > key) {
            cur = cur->_left;
        } else {
            return cur;  // 找到，返回节点指针
        }
    }
    return nullptr;  // 未找到
}

4.2 平衡验证：检查 4 条规则

验证红黑树是否合法，需逐一检查 4 条规则，核心是确保 "无连续红色节点" 和 "黑色节点数量一致"：

  1. 规则1：枚举颜色类型，天然实现保证了颜色不是黑色就是红色。
  2. 规则2：直接检查根即可
  3. 规则3：前序遍历，遇到红色结点查孩子不方便，因为孩子有两个，且不一定存在，反过来检查父亲的颜色就方便多了。
  4. 规则4：前序遍历，遍历过程中用形参记录根当前结点的blackNum(黑色结点数量)，前序遍历遇到黑色结点就++blackNum，走到空就计算出了一条路径的黑色结点数量，再任意一条路径黑色结点数量作为参考值，依次比较即可。


检查代码：

cpp 复制代码 
public:
	bool IsBalanceTree()
	{
		if (_root && _root->_col == Red)
			return false;

		// 最左路径黑色节点的数量做参考值去比较其它路径
		int left_bn = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == Black)
				left_bn++;

			cur = cur->_left;
		}

		return _Checkcolour(_root, 0, left_bn);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}
	int Height()
	{
		return _Height(_root);
	}

	int Size()
	{
		return _Size(_root);
	}
private:
	int _Size(Node* root)
	{
		if (root == nullptr)
			return 0;

		return _Size(root->_left) + _Size(root->_right) + 1;
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		//cout << root->_kv.first << ":" << root->_kv.second << endl;
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	// root_cur_bn 根到当前节点路径上黑色节点的数量
	// 前序递归
	bool _Checkcolour(Node* root, int root_cur_bn, const int left_bn)
	{
		if (root == nullptr)
		{
			// 检查每条路径的黑色节点数量
			if (root_cur_bn != left_bn)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}

			return true;
		}

		if (root->_col == Black)
		{
			root_cur_bn++;
		}

		// 检查连续的红色节点
		if (root->_col == Red && root->_parent && root->_parent->_col == Red)
		{
			cout << root->_kv.first << "存在连续红色节点" << endl;
			return false;
		}

		return _Checkcolour(root->_left, root_cur_bn, left_bn)
		 && _Checkcolour(root->_right, root_cur_bn, left_bn);
	}

测试：

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
using namespace std;

#include"RBTree.h"

void TestRBTree1()
{
	RBTree<int, int> t;
	// 常规的测试用例
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };

	for (auto e : a)
	{
		if (e == 9)
		{
			int i = 0;
		}

		t.Insert({ e, e });

		cout << "Insert:" << e << "->";
		//t.InOrder();
		cout << t.IsBalanceTree() << endl;
	}
	t.InOrder();

	cout << t.IsBalanceTree() << endl;
}


// 插入一堆随机值，测试平衡，顺便测试一下高度和性能等
void TestRBTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
	}

	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "Insert:" << end2 - begin2 << endl;
	cout << t.IsBalanceTree() << endl;

	cout << "Height:" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;
	size_t begin1 = clock();
	// 确定在的值
	/*for (auto e : v)
	{
		t.Find(e);
	}*/

	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}
	size_t end1 = clock();
	cout << "Find:" << end1 - begin1 << endl;
}

int main()
{
	cout << "测试1：" << endl;
	TestRBTree1();
	cout << endl;
	cout << "测试2：" << endl;
	TestRBTree2();

	return 0;
}


声明：红黑树的删除这里还是不讲，大家可以参考《算法导论》或者《STL源码剖析》

结尾：

html 复制代码 
🍓 我是草莓熊 Lotso！若这篇技术干货帮你打通了学习中的卡点：
👀 【关注】跟我一起深耕技术领域，从基础到进阶，见证每一次成长
❤️ 【点赞】让优质内容被更多人看见，让知识传递更有力量
⭐ 【收藏】把核心知识点、实战技巧存好，需要时直接查、随时用
💬 【评论】分享你的经验或疑问（比如曾踩过的技术坑？），一起交流避坑
🗳️ 【投票】用你的选择助力社区内容方向，告诉大家哪个技术点最该重点拆解
技术之路难免有困惑，但同行的人会让前进更有方向～愿我们都能在自己专注的领域里，一步步靠近心中的技术目标！

结语：红黑树的精髓，在于用 "颜色标记" 替代 "严格高度控制"：4 条规则看似简单，却通过 "变色减少旋转""旋转修复关键失衡"，在平衡与开销间找到最优解。掌握其插入逻辑，不仅能理解 O (logN) 效率的底层支撑，更能体会 "柔性约束" 设计的智慧 ------ 这正是红黑树在工业级场景中经久不衰的核心原因。

✨把这些内容吃透超牛的！放松下吧✨ ʕ˘ᴥ˘ʔ づきらど

相关推荐
啊董dong1 小时前
课后作业-2025年11月23号作业
数据结构·c++·算法·深度优先·noi
曹牧1 小时前
C#：姓名脱敏
开发语言·c#
缺点内向1 小时前
C# 中 Word 文档目录的插入与删除指南
开发语言·c#·word·.net
0wioiw01 小时前
跨网络互联技术（Nginx反向代理）
服务器·网络·nginx
r***d8651 小时前
Rust宏编程指南
开发语言·后端·rust
czhc11400756631 小时前
C# 1120抽象类 static
java·开发语言·c#
IT_陈寒1 小时前
Python 3.12新特性解析：10个让你代码效率提升30%的实用技巧
前端·人工智能·后端
你不是我我1 小时前
【Java 开发日记】有了解过 SpringBoot 的参数配置吗？
java·开发语言·spring boot
q***49451 小时前
SpringBoot Maven 项目 pom 中的 plugin 插件用法整理
spring boot·后端·maven
热门推荐
01GitHub 镜像站点02【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连03BongoCat - 跨平台键盘猫动画工具04UV安装并设置国内源05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南07Linux下V2Ray安装配置指南08Spring Boot 4.0 发布总结：新特性、依赖变更与升级指南09全球最强模型Grok4，国内已可免费使用！（附教程）10Labelme从安装到标注：零基础完整指南