红黑树的实现与应用

最新推荐文章于 2025-06-17 18:24:12 发布
原创 最新推荐文章于 2025-06-17 18:24:12 发布 · 5.7k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨红黑树的数据结构及其在平衡二叉查找树中的应用，通过具体代码实现红黑树的插入、查找与删除操作，并分析其在算法效率上的优势。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

正如这篇博文中说到的金山网络面试经历  http://blog.youkuaiyun.com/huruzun/article/details/24634593  面试官要自己设计数据结构实现容器类，需要尽快的实现插入删除查找，在现实实现STL 容器类中红黑树被广泛的应用。

平衡二叉树（BalancedBinary Tree或Height-Balanced Tree）又称AVL树。它或者是一棵空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。若将二叉树上结点的平衡因子BF（BalanceFactor）定义为该结点的左子树的深度减去它的右子树的深度，则平衡二叉树上所有结点的平衡因子只可能是-1、0和1。（此段定义来自严蔚敏的《数据结构（C语言版）》）

红黑树严格意义上不满足平衡因子绝对值小于等于1情况，下面代码就进行测试。

我们知道一颗高度为h的二叉查找树可以实现任何一种基本的动态集合操作，其时间复杂度为 O（h）。这样在树高度比较低时，基本动态操作如插入、删除 会执行的很快，但是当树的高度较高是，尤其是极端情况下的树结构 退化成链表插入删除效率。如上面所说红黑树是许多“平衡的”的查找树中一种，它能保证在最坏情况下，基本动态集合操作的时间为 O（lgn）n 为树结点数目。

本文代码实现参考下面两篇博文感谢作者：http://blog.youkuaiyun.com/npy_lp/article/details/7420689

http://blog.youkuaiyun.com/v_JULY_v/article/details/6114226    JULY 博客强力推荐，他对算法理解很好。

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using namespace std;
typedef int key_t;
typedef int data_t;

typedef enum color_t
{
	RED = 0,
	BLACK = 1
}color_t;

typedef struct rb_node_t
{
	struct rb_node_t *left, *right, *parent;
	key_t key;
	data_t data;
	color_t color;
}rb_node_t;


/* forward declaration */
rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root);
rb_node_t* rb_search(key_t key, rb_node_t* root);
rb_node_t* rb_erase(key_t key, rb_node_t* root);

static rb_node_t* rb_rotate_left(rb_node_t* node, rb_node_t* root)
{

	rb_node_t* right = node->right;
	if ((node->right = right->left))//注意括号里面只是一个等号
	{
		right->left->parent = node;
	}
	right->left = node;
	if ((right->parent = node->parent))
	{
		if (node == node->parent->right)
		{
			node->parent->right = right;
		}
		else
		{
			node->parent->left = right;
		}
	}
	else
	{
		root = right;
	}
	node->parent = right;
	return root;
}


static rb_node_t* rb_rotate_right(rb_node_t* node, rb_node_t* root)
{
	rb_node_t* left = node->left;
	if ((node->left = left->right))
	{
		left->right->parent = node;
	}
	left->right = node;
	if ((left->parent = node->parent))
	{
		if (node == node->parent->right)
		{
			node->parent->right = left;
		}
		else
		{
			node->parent->left = left;
		}
	}
	else
	{
		root = left;
	}
	node->parent = left;
	return root;
}


static rb_node_t* rb_insert_rebalance(rb_node_t *node, rb_node_t *root)
{
	rb_node_t *parent, *gparent, *uncle, *tmp;
	//循环大的控制条件是 node 的 parent 颜色是红色才进入循环处理
	while ((parent = node->parent) && parent->color == RED)
	{
		gparent = parent->parent;
		if (parent == gparent->left)
		{
			uncle = gparent->right;//情况 1 node的叔叔是红色的情况
			if (uncle && uncle->color == RED)
			{
				uncle->color = BLACK;
				parent->color = BLACK;
				gparent->color = RED;
				node = gparent;
			}//情况 2 ，3 node 的叔叔是黑色的
			else
			{
				//情况 2 node 是parent的右孩子 
				if (parent->right == node)
				{
					root = rb_rotate_left(parent, root);
					// 左旋过后 交换 parent与node 位置
					tmp = parent;
					parent = node;
					node = tmp;
				}
				//情况 3 node 是parent的左孩子 
				parent->color = BLACK;
				gparent->color = RED;
				root = rb_rotate_right(gparent, root);
			}
		}
		// 算法导论中写道 ：same as then with "right" and "left" exchanged 下面代码实现类似，只是把left换成 right
		else
		{
			uncle = gparent->left;
			if (uncle && uncle->color == RED)
			{
				uncle->color = BLACK;
				parent->color = BLACK;
				gparent->color = RED;
				node = gparent;
			}
			else
			{
				if (parent->left == node)
				{
					root = rb_rotate_right(parent, root);
					tmp = parent;
					parent = node;
					node = tmp;
				}
				parent->color = BLACK;
				gparent->color = RED;
				root = rb_rotate_left(gparent, root);
			}
		}
	}
	root->color = BLACK;
	return root;
}

static rb_node_t* rb_new_node(key_t key, data_t data)
{
	rb_node_t *node = (rb_node_t*)malloc(sizeof(struct rb_node_t));
	if (!node)
	{
		printf("malloc error!\n");
		exit(-1);
	}
	node->key = key, node->data = data;
	return node;
}

static rb_node_t* rb_search_auxiliary(key_t key, rb_node_t* root, rb_node_t** save)
{
	rb_node_t *node = root, *parent = NULL;
	int ret;
	while (node)
	{
		parent = node;
		ret = node->key - key;
		if (0 < ret)
		{
			node = node->left;
		}
		else if (0 > ret)
		{
			node = node->right;
		}
		else
		{
			return node;
		}
	}
	if (save)
	{
		*save = parent;
	}
	return NULL;
}

rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root)
{
	rb_node_t *parent = NULL, *node;
	parent = NULL;
	if ((node = rb_search_auxiliary(key, root, &parent)))//函数返回node需要插入的位置，并且更新parent为node的parent
	{
		return root;//node 已经存在情况直接返回
	}
	node = rb_new_node(key, data);//产生新结点函数，更好实现模块化
	//新插入节点left right 指向NULL ，颜色给成红色
	node->parent = parent;
	node->left = node->right = NULL;
	node->color = RED;
	// 使得parent 指向 node结点
	if (parent)
	{
		if (parent->key > key)
		{
			parent->left = node;
		}
		else
		{
			parent->right = node;
		}
	}
	else
	{
		root = node;
	}
	return rb_insert_rebalance(node, root);
}

rb_node_t* rb_search(key_t key, rb_node_t* root)
{
	return rb_search_auxiliary(key, root, NULL);
}

static rb_node_t* rb_erase_rebalance(rb_node_t *node, rb_node_t *parent, rb_node_t *root)
{
	rb_node_t *other, *o_left, *o_right;
	while ((!node || node->color == BLACK) && node != root)
	{
		if (parent->left == node)
		{
			other = parent->right;
			if (other->color == RED)
			{
				other->color = BLACK;
				parent->color = RED;
				root = rb_rotate_left(parent, root);
				other = parent->right;
			}
			if ((!other->left || other->left->color == BLACK) &&
				(!other->right || other->right->color == BLACK))
			{
				other->color = RED;
				node = parent;
				parent = node->parent;
			}
			else
			{
				if (!other->right || other->right->color == BLACK)
				{
					if ((o_left = other->left))
					{
						o_left->color = BLACK;
					}
					other->color = RED;
					root = rb_rotate_right(other, root);
					other = parent->right;
				}
				other->color = parent->color;
				parent->color = BLACK;
				if (other->right)
				{
					other->right->color = BLACK;
				}
				root = rb_rotate_left(parent, root);
				node = root;
				break;
			}
		}
		else
		{
			other = parent->left;
			if (other->color == RED)
			{
				other->color = BLACK;
				parent->color = RED;
				root = rb_rotate_right(parent, root);
				other = parent->left;
			}
			if ((!other->left || other->left->color == BLACK) &&
				(!other->right || other->right->color == BLACK))
			{
				other->color = RED;
				node = parent;
				parent = node->parent;
			}
			else
			{
				if (!other->left || other->left->color == BLACK)
				{
					if ((o_right = other->right))
					{
						o_right->color = BLACK;
					}
					other->color = RED;
					root = rb_rotate_left(other, root);
					other = parent->left;
				}
				other->color = parent->color;
				parent->color = BLACK;
				if (other->left)
				{
					other->left->color = BLACK;
				}
				root = rb_rotate_right(parent, root);
				node = root;
				break;
			}
		}
	}
	if (node)
	{
		node->color = BLACK;
	}
	return root;
}


rb_node_t* rb_erase(key_t key, rb_node_t *root)
{
	rb_node_t *child, *parent, *old, *left, *node;
	color_t color;
	//先查找删除结点值是否存在
	if (!(node = rb_search_auxiliary(key, root, NULL)))
	{
		printf("key %d is not exist!\n");
		return root;
	}
	old = node;
	if (node->left && node->right)
	{
		node = node->right;
		while ((left = node->left) != NULL)
		{
			node = left;
		}
		child = node->right;
		parent = node->parent;
		color = node->color;
		if (child)
		{
			child->parent = parent;
		}
		if (parent)
		{
			if (parent->left == node)
			{
				parent->left = child;
			}
			else
			{
				parent->right = child;
			}
		}
		else
		{
			root = child;
		}
		if (node->parent == old)
		{
			parent = node;
		}
		node->parent = old->parent;
		node->color = old->color;
		node->right = old->right;
		node->left = old->left;
		if (old->parent)
		{
			if (old->parent->left == old)
			{
				old->parent->left = node;
			}
			else
			{
				old->parent->right = node;
			}
		}
		else
		{
			root = node;
		}
		old->left->parent = node;
		if (old->right)
		{
			old->right->parent = node;
		}
	}
	else
	{
		if (!node->left)
		{
			child = node->right;
		}
		else if (!node->right)
		{
			child = node->left;
		}
		parent = node->parent;
		color = node->color;
		if (child)
		{
			child->parent = parent;
		}
		if (parent)
		{
			if (parent->left == node)
			{
				parent->left = child;
			}
			else
			{
				parent->right = child;
			}
		}
		else
		{
			root = child;
		}
	}
	free(old);
	if (color == BLACK)
	{
		root = rb_erase_rebalance(child, parent, root);
	}
	return root;
}
void inorder(rb_node_t *root)
{
	if (root!=NULL)
	{
		inorder(root->left);
		cout<<"key="<<root->key<<" color="<<root->color<<endl;
		inorder(root->right);
	}
}

int main()
{

	int test[6]={41,38,31,12,19,8};
	rb_node_t* root = NULL, *node = NULL;
	int i;
	for (i=0;i<6;i++)
	{
		if ((root = rb_insert(test[i], i, root)))
		{
			printf("[i = %d] insert key %d success!\n", i+1, test[i]);
		}
		else
		{
			printf("[i = %d] insert key %d error!\n", i+1, test[i]);
			exit(-1);
		}
	}
	inorder(root);

	return 0;
}



main 函数测试了算法导论给的思考题。
如果读者不理解算法过程可以参考算法导论或者JULY博文：http://blog.youkuaiyun.com/v_JULY_v/article/details/6109153

红黑树初解
qq_35540164的博客
08-22 841
红黑树初解 今天来复习一下红黑树的知识点，推荐51CTO这个微信公众号。 学过数据结构都知道二叉树的概念，而又有多种比较常见的二叉树类型，比如完全二叉树、满二叉树、二叉搜索树、均衡二叉树、完美二叉树等。 今天我们要说的红黑树就是就是一棵非严格均衡的二叉树，均衡二叉树又是在二叉搜索树的基础上增加了自动维持平衡的性质，插入、搜索、删除的效率都比较高。红黑树也是实现 TreeMap 存储结构的基石。 二...
红黑树精通指南：面试、实战与源码分析
热门推荐
张彦峰的博客
05-12 177万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
红黑树的简单应用
qq_33404145的博客
11-17 534
红黑树的简单应用
数据结构（十三）：红黑树
最新发布
weixin_72359141的博客
06-17 809
一棵红黑树是满足如下红黑性质的二叉排序树：① 每个结点或是红色，或是黑色的。② 根结点是黑色的。③ 叶结点(虚构的外部结点、NULL结点)都是黑色的。④ 不存在两个相邻的红结点(即红结点的父结点和孩子结点均是黑色的)。⑤ 对每个结点，从该结点到任意一个叶结点的简单路径上，所含黑结点的数量相同。假如给一个红黑树，最短路径长什么样子?最短路径肯定都是全黑的，一个红色节点都不要加入给一个红黑树，最长路径长什么样子?由于性质4"路黑同。
红黑树实现
Mythical_Man_Month的专栏
08-16 1005
几点说明： 1、网上给出的一些红黑树实现示例固定了节点类型，关键字，不适合很多应用场景 2、网上给出的一些红黑树实现不能兼容节点属于多个红黑树 3、函数、变量、类型等命名不符合一般的linux风格，但有一定的原则（公司习惯遗留下来） 4、接口尽量正交、易用、最小化，不提供没有必要支持的功能，如一棵树中的节点个数（这个由使用者自己统计） 5、添加接口：只需要设置好关键字就可以正常添加，返回
红黑树的应用----TreeMap
帆心
11-24 446
红黑树是一种类似于平衡二叉树的结构 特点 : 根结点是黑的。 每个节点非黑即红 如果节点为红 那么其子节点肯定是黑色(注意 : 没有2个相邻的红节点) 叶节点下面有2个null的黑色子节点 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。 public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serial.
深入探索红黑树：Python实现与应用
11-05
红黑树是一种自平衡的二叉查找树，它能够确保树中的最长路径不会超过...红黑树的实现和应用是计算机科学中的基础知识点，通过学习红黑树，可以加深对数据结构和算法的理解，并在实际开发中，有效提升数据操作的效率。
红黑树与区间树算法实现
04-08
红黑树和区间树是两种在计算机科学中广泛使用的数据结构，主要应用于高效的数据管理和查询。在本实验中，我们探讨了如何用C++来实现这两种数据结构，并提供了相关的可视化功能。 红黑树是一种自平衡二叉查找树，由...
红黑树的实现原理和应用场景
lssffy的博客
04-01 1023
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它通过特定的规则确保树在插入和删除操作后能保持相对平衡，从而保证查找、插入、删除等操作的时间复杂度为O(log n)。红黑树是一种高效的自平衡二叉查找树，通过精心设计的平衡规则和旋转操作，在各种动态数据管理场景中表现出色。虽然实现相对复杂，但其优秀的综合性能使其成为许多高级数据结构和系统组件的首选实现方式。理解红黑树的原理和实现，对于深入掌握计算机科学中的数据结构和算法设计具有重要意义。
搞懂红黑树及其应用场景
WULI_LIN的博客
11-27 5376
红黑树 1 性质 1. 每个结点是红的或黑的 2. 根结点是黑的 3. 每个叶子结点是黑色的 4. 如果一个结点是红的，则它的两个儿子都是黑的（不能有连续两个红色结点） 5. 对每个结点，从该节点到其子孙结点的所有路径上的包含相同数目的黑结点 2 插入 插入结点时默认是插入的红色结点，因为只有插入红色结点，在没调整的情况下，才能保证性质 5（所有路径包含相同数目的黑结点） 因为插入的结点为红色，因此如果父结点也为红色，则需要调整 调整方法 1). 插入结点为根结点 --> 变色 2). 插入结点的
红黑树的用途和实现
twopq的博客
11-08 3284
一、红黑树用途在哪里？ 1 map–> 2 nginx–> 3 定时器–> 4 cfs （进程调度的集合 ）（操作系统中用红黑树存储的集合）（查找速度快，有顺序） 5 内存管理（红黑树的平衡关系）； 问题：典型的malloc的内存碎片？ 解答：一块内存对应一个key； key指向的内存的地址 加上长度就是对内存碎片的管理， key value -->查找。 问题：红黑树有什么应用呢？ 1>大多数自平衡BST(self-balancing BST) 库函数都是用红黑树实现的，比如
红黑树的概念及应用
2201_75999403的博客
08-04 978
红黑树
红黑树的优点
Pandoras Box
09-03 3万+
//转自wangyu： 红黑树是一种很有意思的平衡检索树。它的统计性能要好于平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以
红黑树及其应用介绍（万字长文）
sinat_30545761的博客
08-30 786
红黑树是一种特殊的二叉查找树，它遵循了特定的规则使得其具有了平衡性。红黑树在很多领域中都有广泛的应用，例如操作系统、数据库、图形学等。它的平衡性和高效的操作性能使得它成为一种非常优秀的数据结构。
java算法- 红黑树
灰猫
01-07 287
treeMap 也是使用红黑树实现的 package com.numberone.tree; /** * 红黑树 */ public class RBTree<T extends Comparable<T>> { private final RBTreeNode<T> root; //node number private j...
红黑树的实现
tunyue456的专栏
04-11 396
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树的五条性质：（特别重要） 1.节点是红色或黑色 2.根节点是黑色 3. 每个叶节点（NIL节点，空节点）是黑色的，又称为外节点 4.如果一个节点是红色的，则他的两个子节点都是黑色的 5.对每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的
红黑树 rbtree 实现与应用
红黑树是一种自平衡的二叉查找树，其在插入和删除操作时能够通过旋转和重新着色保持树的平衡，从而保证搜索、插入、删除...在实际编程中，通常会使用现成的红黑树实现，如C++ STL或Java集合框架中提供的红黑树结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值