【C++修炼之路】20.手撕红黑树

已于 2023-02-20 12:49:50 修改
阅读量3.1k 收藏 10
点赞数 8
分类专栏： C++ 文章标签： c++ 算法 数据结构
于 2023-02-20 12:40:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NEFUT/article/details/129122061
版权
文章详细介绍了红黑树的概念、性质以及插入操作，包括只变色、变色加单旋和双旋三种情况。红黑树相比AVL树，允许轻微的不平衡，降低了旋转频率，适合频繁插入操作。同时，文章提供了红黑树的C++实现代码片段，并给出了与AVL树的性能比较。
摘要由CSDN通过智能技术生成

在这里插入图片描述
每一个不曾起舞的日子都是对生命的辜负

红黑树实现:RBTree

前言

在上一节中我们学到了AVL树的结构及其相关性质，对于平衡树来说，AVL无疑是最完美的结构，但实际上AVL树由于完美的结构因此也要花费一定的代价，由于AVL树的结构很敏感，查找虽然最快，但插入节点后一旦偏离AVL结构就会进行旋转，而旋转就会花费一定的性能。因此我们提到的map和set的底层为了防止这种性能上的缺失，即便AVL是非常完美的结构，也不采用AVL。而是采用我们这节所要描述的红黑树。

一.红黑树的概念及性质

1.1 红黑树的概念

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

可见红黑树的这种结构，虽然在不满足条件时会发生旋转，但敏感程度相比AVl树大大降低。

image-20230215124244019

1.2 红黑树的性质

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
  5. 每个叶子结点都是黑色的（此处的叶子结点指的是空结点）

需要注意的是：对于性质3，意思就是没有连续的红色结点。

思考： 为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

就上面的这颗红黑树来说，有11条路径（需算到空）我们只观察黑色结点，发现是接近满二叉树的。对于红黑树的最短路径，最短的极限情况就是一条路径全是黑色的结点，因为其他路径也会有相同数目的黑节点加上一定数量的红色结点，而最长路径就是一黑一红相间的路径。可见，最长的结点个数是最短结点个数的二倍。

image-20230215125646671

这样就是红黑树的结构，且存在最长和最短的情况，最短为最长的二分之一。

由于红黑树确保没有一条路径会比其他路径长出俩倍，因此可以看成近似平衡，对于这种不确定的结构，自然就有最好的情况和最坏的情况。

  • 最好情况：（左右平衡）

全黑或者每条路径都是一黑一红相间的路径，接近满二叉树。那么此时设全黑的路径长度为h结点数量为N，则2^h - 1 + _ = N（_代表红色结点，由于一条路径红色结点数量一定小于等于黑色，所以可以忽略计算）此时，h = logN。

  • 最坏情况：（左右极其不平衡）

左子树全黑，且右子树一黑一红。那么此时最长路径为2*logN。

总结： 可以看出，在对数的加持下，即便是最坏情况，对于计算机来说相差也不是很大。虽不如AVL的极度平衡，但红黑树明显在插入节点时显得张弛有力。对于AVL来说，说是过刚易折也不为过，往往像红黑树那样增加一定的柔韧性，才是最后的选择。

二.红黑树的结构

2.1 红黑树节点的定义

相比较AVL树，红黑树的结点仍是三叉链这个结构，为后续不满足结构的条件旋转做准备。此外，和AVL树结点不同的是，红黑树不再有平衡因子这一变量，而是多了一个定义颜色的变量，颜色变量通过枚举实现。下面看看结点定义的代码：

enum Color//颜色采用枚举，但STL库采用的是特殊的bool值，后续会看
{
	RED,//0
	BLACK,//1
};

template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _col;

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_col(RED)//默认哪种颜色都可以，因为后续会改
	{}

};

2.2 红黑树类的封装

enum Color//颜色采用枚举，但STL库采用的是特殊的bool值，后续会看
{
	RED,//0
	BLACK,//1
};

template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _col;

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_col(RED)//默认哪种颜色都可以，因为后续会改
	{}

};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
    //成员函数
    bool Insert(const pair<K, V>& kv)
    {
        
    }
private:
	Node* _root = nullptr;
};

三.红黑树的插入

与AVL树一样，在插入中需要考虑的因素众多，但相比AVL，红黑树在插入时的情况少很多，因为其结构没有AVL树的高度平衡。

在红黑树的性质中，第三，第四条尤为重要。即：

  • 如果一个节点是红色的，则它的两个孩子结点是黑色的
  • 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

如果我们新插入的结点的颜色为黑的话，插入之后一定会打破上述第二个结构，导致每条路径的黑结点数量不同；如果新插入的节点的颜色为红色的话，也有可能不满足情况，如果插入节点的父节点为黑的话还好，但如果父节点为红，也就不满足这个条件了。因此，插入节点的颜色尤为重要，经过上述考虑，插入节点的颜色为红无疑是最好的选择，因为有可能满足条件，有可能不满足条件，但插入黑色一定不满足。如果插入红色的也不满足，那就后期处理就好了。

  • 插入节点的颜色必须为红

检测新节点插入后，红黑树的性质是否造到破坏
因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：
约定: cur为当前（插入）节点，p为父节点，g为祖父节点，u为叔叔节点

对于新节点的插入，与父节点和父节点的兄弟节点也有关，下面就看看各种情况：

情况1：只变色

  • cur为红，p为红，g为黑，u存在且为红

image-20230215145901714

通过上面图的步骤，我们大致知道了思路，如果红色结点连续，为了满足红黑树的不能有连续红色结点的性质，我们需要将其双亲也就是父亲结点变成黑色，如果这棵树是子树，那么为了保证黑色结点数量不变，我们需要将g变红，如果g的双亲仍是红色，那么就一直往上更新迭代。对于上图，实际上同样是个抽象图，因为a,b,c,d,e可以使任意的红黑树子树，情况也会随着这几个抽象树节点的增加而变化的非常多，因此我们只需要牢记这种抽象图即可。

cur和p均为红，违反了性质三，此处能否将p直接改为黑？
解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

可以看出，红色结点的增加是因为插入节点，黑色节点的增加是为了保证红黑树结构的性质从红色结点变化而来的。

情况2：变色+单旋

  • cur为红，p为红，g为黑，u不存在/u存在且为黑

image-20230215151246360

如果不存在叔叔结点u，那么是这样的结构：image-20230215153215295

此时，新增的cur节点为红，那我们必须想办法将p变黑，此时就可以考虑将g为轴进行旋转的方式image-20230215153745528

这样，就可以使其满足红黑树的结构了，u结点存在且为黑和此同理。

接下来看看步骤：

p为g的左孩子，cur为p的左孩子，则g进行右单旋转；相反，
p为g的右孩子，cur为p的右孩子，则g进行左单旋转
p、g变色–p变黑，g变红

情况3：双旋

  • cur为红，p为红，g为黑，u不存在/u存在且为黑

看似与情况二一样，实际上区别是cur插入的左右不同。情况2为左，情况3为右。

image-20230215155228807

和上篇中的AVL一样，对于这种弯的结构，只进行一次旋转是不可能成功的，因此需要进行两部旋转，上图只旋转了一次，变成了情况2，因此需要再旋转一次，就能满足红黑树结构的性质。

步骤：

  1. p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转。
    则转换成了情况2。转换成情况2之后，再根据情况2的步骤继续旋转：
  2. p为g的左孩子，cur为p的左孩子，则g进行右单旋转；相反，p为g的右孩子，cur为p的右孩子，则g进行左单旋转
    p、g变色–p变黑，g变红

image-20230215161337990

注意，经过左旋，变色位置不变，但对应位置的结点变了，因此在代码编写时需注意这个问题。

插入的代码实现：

注：Insert单拿出来观察，其利用的旋转函数与AVL一样，只不过去掉了平衡因子。

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;
        cur->_parent = parent;
    }
    else
    {
        parent->_left = cur;
        cur->_parent = parent;
    }

    while (parent && parent->_col == RED)//如果父亲的颜色为红，才需要去处理
    {
        Node* grandfather = parent->_parent;//找到祖父才能找到叔叔
        if (parent == grandfather->_left)
        {
            Node* uncle = grandfather->_right;
            //看叔叔颜色
            //情况1：uncle存在且为红
            if (uncle && uncle->_col == RED)
            {
                parent->_col = uncle->_col = BLACK;
                grandfather->_col = RED;

                cur = grandfather;
                parent = cur->_parent;
            }
            else//情况2或3：不用考虑叔叔的问题，即叔叔为空还是为黑
            {
                if (cur == parent->_left)//情况2
                {
                    //     g
                    //   p
                    // c
                    RotateR(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                }
                else//情况3
                {
                    //     g
                    //   p
                    //     c
                    RotateL(parent);
                    RotateR(grandfather);
                    cur->_col = BLACK;
                    grandfather->_col = RED;
                }
                break;
            }
        }
        else//与上述代码的左右反过来了而已，步骤一样但左右相反。
        {
            Node* uncle = grandfather->_left;
            //情况1
            if (uncle && uncle->_col == RED)
            {
                parent->_col = uncle->_col = BLACK;
                grandfather->_col = RED;

                cur = grandfather;
                parent = cur->_parent;
            }
            else//情况2和3
            {
                //  g
                //     p
                //        c
                if (cur == parent->_right)
                {
                    RotateL(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                }
                else
                {
                    //  g
                    //     p
                    //   c
                    RotateR(parent);
                    RotateL(grandfather);
                    cur->_col = BLACK;
                    grandfather->_col = RED;
                }
            }
        }
    }
    _root->_col = BLACK;
    return true;
}

此外，有插入就有删除，删除是插入的反向思维。删除太难了，不用学。真想了解看这个，但是没有代码：红黑树 - Never - 博客园 (cnblogs.com)

四.红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质

函数代码：

bool IsBalance()//检查是否为红黑树结构
{
    if (_root == nullptr)
    {
        return true;
    }

    if (_root->_col != BLACK)
    {
        return false;
    }

    int ref = 0;
    Node* left = _root;
    while (left)
    {
        if (left->_col == BLACK)
        {
            ++ref;
        }

        left = left->_left;
    }
    //遍历这棵树，就好了，检查是否存在连续的红结点。
    //检查父亲，因为孩子不一定有，但是一定有父亲
    return Check(_root, 0, ref);
}
bool Check(Node* root, int blackNum, int ref)
{
    if (root == nullptr)
    {
        if (blackNum != ref)
        {
            cout << "违反规则：一条路径上的黑色节点数量不同" << endl;
            return false;
        }
        return true;
    }

    if (root->_col == RED && root->_parent->_col == RED)
    {
        cout << "违反规则，出现连续红色结点" << endl;
    }
    if (root->_col == BLACK)
    {
        ++blackNum;
    }
    return Check(root->_left, blackNum, ref)
        && Check(root->_right, blackNum, ref);
}

五.红黑树实现代码（完整）

随机插入构建红黑树：
在这里插入图片描述
以升序插入构建红黑树：
在这里插入图片描述
以降序插入构建红黑树：
在这里插入图片描述

RBTree.h

#pragma once

enum Color//颜色采用枚举，但STL库采用的是特殊的bool值，后续会看
{
	RED,//0
	BLACK//1
};

template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _col;

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}

};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
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;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)//如果父亲的颜色为红，才需要去处理
		{
			Node* grandfather = parent->_parent;//找到祖父才能找到叔叔
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//看叔叔颜色
				//情况1：uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2或3：不用考虑叔叔的问题，即叔叔为空还是为黑
				{
					if (cur == parent->_left)//情况2
					{
						//     g
						//   p
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//情况3
					{
						//     g
						//   p
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else//与上述代码的左右反过来了而已，步骤一样但左右相反。
			{
				Node* uncle = grandfather->_left;
				//情况1
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2和3
				{
					//  g
					//     p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//  g
						//     p
						//   c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
			}
		}

		_root->_col = BLACK;
		return true;

	}

	//旋转代码和AVL一样，只是去掉了平衡因子
	void RotateL(Node* parent)//左单旋
	{
		//1.记录subR, subRL
		Node* subR = parent->_right;
		Node* subRL = subR->_left;


		parent->_right = subRL;
		if (subRL)//subRL不为空则需要连接到parent
		{
			subRL->_parent = parent;
		}

		Node* ppNode = parent->_parent;//记录保存
		subR->_left = parent;
		parent->_parent = subR;

		if (ppNode == nullptr)//说明根节点变化
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else//如果是局部子树
		{
			//判断ppNode之前是左连接还是右连接
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

	}

	void RotateR(Node* parent)//右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

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

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

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

	void Inorder()
	{
		_Inorder(_root);
	}

	bool IsBalance()//检查是否为红黑树结构
	{
		if (_root == nullptr)
		{
			return true;
		}

		if (_root->_col != BLACK)
		{
			return false;
		}

		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLACK)
			{
				++ref;
			}

			left = left->_left;
		}
		//遍历这棵树，就好了，检查是否存在连续的红结点。
		//检查父亲，因为孩子不一定有，但是一定有父亲
		return Check(_root, 0, ref);
	}

private:
	bool Check(Node* root, int blackNum, int ref)
	{
		if (root == nullptr)
		{
			if (blackNum != ref)
			{
				cout << "违反规则：一条路径上的黑色节点数量不同" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "违反规则，出现连续红色结点" << endl;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return Check(root->_left, blackNum, ref)
			&& Check(root->_right, blackNum, ref);
	}

	void _Inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_Inorder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_Inorder(root->_right);
	}
	Node* _root = nullptr;
};

void TestRBTree1()
{
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}

	t.Inorder();


}

Test.cpp

#include<iostream>
#include<string>
#include<map>
#include<assert.h>
using namespace std;
#include"RBTree.h"
int main()
{
	TestRBTree1();
	return 0;
}

六.红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( l o g 2 N log_2 N log2​N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

每天都要进步呀~
关注
专栏目录
数据结构：手撕红黑树(python方式)
Winnie_boy的博客
05-24 1038
前言：不知道同学有没有看完昨天的B树和B+树，虽说那个B+树在面试中很少被要求手写，但是有一个常考的考点，红黑树，可以一个经常被问到的知识噢，那么今天，我就来跟大家一起手撕红黑树！ 红黑树 说到红黑树不得不先提一下AVL树(平衡二叉搜索树)，不了解AVL树的同学可以自行查询相关文献，然后回来以后，请回答我的两个问题： 红黑树和AVL树的区别是什么？ 1.附上红黑颜色属性，通过颜色控制树的平衡 2.相对于AVL树来说，没有那么严格的要求平衡 3.插入和删除的复杂度和次数较AVL来说，跟随着数量节点的增大，越
手撕红黑树——C++高阶数据结构详解
qq_61500888的博客
09-06 1万+
带你一命通关红黑树 十五分钟手撕数据结构原理
保姆级别带你手撕红黑树BRTree
我的学习笔记分享
04-20 1702
一、前言 本文是自己在学习过程中，记录下的一些总结，以便日后复习，同时分享出来，方便与更多人学习交流，共同进步。鄙人水平有限，若有误，请不吝赐教😁😁😁。 二、从头介绍 红黑树树是一种二叉树，比较常用的数据结构，如果对二叉树不是很熟悉或者有遗忘的朋友，可以看看我之前做的笔记。 第一篇介绍二叉树的基础知识：数据结构与算法 树_振予的博客-CSDN博客 第二篇介绍二叉搜索树和二叉平衡树树：数据结构与算法 查找_振予的博客-CSDN博客 三、红黑树介绍 每当我们打开电脑查找一个文档、在教务系统输入我们
手撕红黑树很难？看完零基础都能手撕各种二叉树
qq_43778239的博客
01-14 645
从零基础通过图片和动图来讲解数据结构中二叉树的知识点，并实现常见的二叉树，附带相关leetcode题目，适合零基础或者刚刚入门算法小白阅读，考研的同学也可以来了解了解喔。
【高阶数据结构】手撕红黑树（超详细版本）
qq_42996461的博客
01-08 2518
但行好事，莫问前程
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 845
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
28.红黑树_1.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36哈希与映射的概述 37B树有什么用 38B树的概念 39图_邻接矩阵 40图_邻接表 41图_DFS 42图_BFS
C++——红黑树
最新发布
dongxue727504的博客
12-07 3029
C++之红黑树板块讲解
红黑树面试题目---华为C++工程师
WangY.H
05-06 2254
1.stl中的set底层用的什么数据结构？ 红黑树 2.红黑树的数据结构怎么定义？ [cpp] view plain copy 1 enum Color 2. { 3. RED = 0, 4. BLACK = 1 5. }; 6. 7. struct RBTreeNode 8. { 9. stru...
手撕HashMap红黑树
我与风来
12-30 879
结合红黑树算法，介绍了底层 HashMap 树型化相关的操作。
手撕红黑树（Red-Black Tree）
林慢慢的博客
07-06 3039
红黑树 （C++实现）
手撕TreeMap红黑树
热门推荐
[ 25'h ]
09-03 3万+
一文带你吃透java TreeMap源码。
防老年痴呆系列之手撕红黑树
None
05-11 954
红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组(可以用非负整数或者字符串等不同类型的值作索引的特殊数组)。它是在1972年由鲁道夫·贝尔发明的...
【数据结构】手撕红黑树
学了就忘是正常现象
02-26 9085
红黑树和AVL树一样，因其逻辑复杂，面试时现场要求手撕就是纯纯刁难面试者。但某大厂面试官曾要求某些求职者现场手撕红黑树（我赌5毛，让面试官撕，他也撕不出来，而且你家员工上班手搓红黑树啊？），随后求职遭遇被发到网上吐槽，这便有了“手撕红黑树”的梗，也让红黑树成为了知名度最高的数据结构。（话虽如此，对于红黑树的性质、插入思想等概念还是需要掌握的）
数据结构——手撕红黑树（开肝！）
qq_48201696的博客
08-06 619
数据结构——红黑树（开撕！） 红黑树介绍 在查找算法中，二叉搜索树是一种查找速度非常快的数据结构，平均查找事件复杂度可以达到O(log2(n))但是对于二叉搜索树，其查找性能还是不太稳定,如下面一颗二叉搜索树，如果要查找5这个结点所在的位置，查找过程依然要达到5次，也即线性查找时间，要保证查找速度稳定控制在**O(log2(n))**左右，就需要对这颗二叉搜索树维持平衡，保证其查找速度 所以在二叉搜索树的基础上，有了红黑树这种维护二叉搜索树平衡，保证查找速度保持在对数级别的数据结构，对于红黑树，其结点定义
手撕红黑树RedBlackTree Right？带动画的哦
weixin_43272605的博客
02-20 2万+
首先这篇博客花了一点时间才总结出来，肯定还有错误，希望各位读者能够小心翼翼的看。尽量理解吧，因为我自己水平也很菜哈哈。 首先红黑树是一个二叉查找树，就是加了各种限制，让他成为了一种自平衡的二叉树。首先来看看它的五大特性，这也是我们必须要牢记的，后面多次提到，但我还是会多次重复。 GO????黑????GO 树的节点要么是红色的，要么就是黑色的（这是废话，不然怎么叫红黑树） 树的根节点一定是黑色的 ...
【数据结构与算法】手撕红黑树
pythonxxoo的博客
04-02 861
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 红黑树 定义 动机： 二叉查找树查找、插入、删除最坏情况时间复杂度可能退化为 O(n)。 AVL 树很好的限制了数的高度为 O(logn)，插入、删除、查找的最坏时间复杂度均为 O(logn)；但删除操作最多需要做 O(logn) 次旋转。 红黑树是具有如下特点的二
什么是红黑树
qq_38933706的博客
12-09 306
本文转载自掘金程序员小灰 漫画很容易懂，受益匪浅 学习红黑树之前，先说一下二叉查找树吧！ 二叉查找树（BST）具备什么特性呢？ 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 下图中这棵树，就是一颗典型的二叉查找树： 这样的数据结构有什么好处呢？让我们来找一下值为10 的结点。
C++红黑树实现源代码解析
本资源提供了一份使用C++语言编写的红黑树的实现源代码，包括两个文件：task9.1.cpp和rbtree.h。task9.1.cpp文件可能包含红黑树的实现逻辑，包括节点结构定义、插入、删除、查找等操作的具体实现代码。而rbtree.h...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

每天都要进步呀~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值