【C++】红黑树的简单模拟实现

已于 2024-04-13 09:08:32 修改
阅读量402 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 数据结构
于 2022-02-22 17:15:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51064412/article/details/120363928
版权

文章目录

一. 什么是红黑树？

1. 基本概念

红黑树和AVL树类似，是对搜索树的优化。不同于AVL树的绝对平衡，红黑树是近似平衡，即对于每个节点的以它为根的所有路径，其中最长路径的节点数不大于最短路径节点数的2倍。

2. 红黑树的特性

  • 每个节点不是红色就是黑色，其中根节点为黑
  • 红色节点不连续，即红色节点的左右孩子只能为黑色
  • 每个节点，以它为根的所有路径中黑色节点的数量相同

以上特性，就是红黑树近似平衡的原因：

  1. 红色节点不连续，说明最短路径的节点都是黑色，最长路径的节点是红黑相间。
  2. 每条路径节的黑色节点个数必须相同，决定了最短路径不超过最长路径的2倍。
    在这里插入图片描述

二. 为什么要有红黑树？

为什么要有红黑树？下面通过红黑树和搜索树、平衡树的比较来回答这个问题。

1. 红黑树和搜索树

当插入有序数据时，搜索树会退化为单枝树从而导致查找效率降为线性。红黑树通过对各个节点颜色的控制和位置的调整，使得树永远处于近似平衡状态，保证了O(logN)的查找效率。
在这里插入图片描述

2. 红黑树和平衡树

二者都是对搜索树进行了平衡处理

  • 平衡树是绝对平衡：左右子树高度差的绝对值小于等于1
  • 红黑树是近似平衡：最长路径不大于最短路径的2倍

红黑树不追求绝对平衡，相对平衡树而言降低了插入和删除时旋转的次数，频繁的插入删除红黑树的性能更优，并且红黑树的实现也较为简单，所以实际运用中红黑树更多。如果插入删除的操作较少且需要频繁的查找，那么平衡树性能更优。

三. 红黑树插入操作实现

1. 基本框架

主要定义里两个类：节点类 + 树的本体，其中前者存储节点节点的相关信息，后者主要实现红黑树的功能，如插入、删除、查找等。

1.1 节点类框架

数据域：颜色（默认为红）、pair键值对
指针域：左孩子和右孩子、父亲

// 枚举定义颜色
enum COLOR
{
  RED,
  BLACK
};

// 节点的定义
template<class k, class v>
struct RBTreeNode
{
  // 构造函数，颜色默认给为红色
  RBTreeNode(const pair<k, v>& kv)
    :_color(RED)
    ,_kv(kv)
    ,_parent(nullptr)
    ,_left(nullptr)
    ,_right(nullptr)
  {}

  COLOR _color;
  pair<k, v> _kv;
  RBTreeNode<k, v>* _parent;
  RBTreeNode<k, v>* _left;
  RBTreeNode<k, v>* _right;
};

为什么颜色默认为红色？

因为红色处理起来更简单，对其他路径的波及较小。如果为黑色，想想看这条路径的黑色节点数量加了一个，那么其他路径都要调整来保证所有路径的黑色节点个数一致；但是如果置为红色，这时只有插入位置的父亲也为红才需要调整，即使调整也只需调整一条路径，比较容易。

1.2 树本体框架

只有一个成员变量就是一个节点的指针，代表树的根节点。也为只有一个成员变量，可以不用写构造函数，我们直接声明时给缺省值即可，就是把它置为nullptr。

// 树的定义
template<class k, class v>
class RBTree
{
public:
	typedef RBTreeNode<k, v> Node;
private:
	Node* _root = nullptr;// 声明时给缺省值
};

2. 第一步：按搜索树性质插入节点

按搜索树的性质来找到插入的位置，然后直接插入：

  • 如果是空树，则则该插入节点就作为整棵树的根，并把颜色改为黑色
  • 非空的话，按照搜索树的性质找到插入的位置和并记录父亲，然后和父亲的key比较来决定作为左孩子还是右孩子。
template<class k, class v>
class RBTree 
{
  public:
    typedef RBTreeNode<k, v> Node;
    
    bool Insert(const pair<k, v>& kv)
    {
      // 第一步：按搜索树规则插入一个节点
      // 1、空树的话插入节点作为根节点
      // 2、不空的话，按搜索树规则找到插入的位置，然后插入
      if(!_root)
      {
        _root=new Node(kv);
        _root->_color=BLACK;
        return true;
      }
      // 寻找插入的位置
      Node* parent=nullptr;
      Node* cur=_root;
      while(cur)
      {
        parent=cur;
        if(cur->_kv.first == kv.first)
        {
          return false;
        }
        else if(cur->_kv.first < kv.first)
        {
          cur=cur->_right;
        }
        else if(cur->_kv.first > kv.first)
        {
          cur=cur->_left;
        }
      }
      // 找到后插入
      Node* newNode=new Node(kv);
      newNode->_parent=parent;
      if(parent->_kv.first > kv.first)
      {
        parent->_left=newNode;
      }
      else if(parent->_kv.first < kv.first) 
      {
        parent->_right=newNode;
      }
      // 未完待续.....

	private:
		Node* _root=nullptr;
};

3. 第二步：调整节点的颜色

3.1 调整操作

走到了这一步，那么插入节点肯定不是整棵树的根了，因为空树情况在第一步里面已经处理好了，也就是说现在插入的新节点一定有父亲。根据父亲的颜色分两种情况处理：

  1. 情况一：父亲颜色为黑。这种情况就不用调整了，插入结束。
  2. 情况二：父亲颜色为红。需要调整

针对情况二，我们需要知道，这时一定是有祖父节点的，即父亲的父亲一定存在且为黑色，因为父亲的颜色为红不可能是根节点，又因为红色不连续所以祖父为黑。这时我们的调整取决于叔叔，当然叔叔可能存在也可能不存在，我们分情况处理。

约定插入节点为cur，父亲为parent，祖父为gfather，叔叔为uncle，此时：

  • uncle存在且为红 --》 把parent和uncle的颜色到改为黑，gfather颜色改为红，从gfather开始继续往上调整。
    在这里插入图片描述
  • uncle 不存在 or 存在且为黑 --》依照gfather、parent、cur的关系来旋转处理。
    在这里插入图片描述
// 拼接到第一步代码后面
// 第二步：调整节点的颜色
// 1、如果父亲颜色为黑就不用调整
// 2、如果父亲节点颜色为红，调整方式由叔叔决定
//    a、叔叔存在且为红 --> 把叔叔和父亲的颜色调整为黑，爷爷颜色调整为红，然后继续往上调整
//    b、叔叔不存在或存在且为黑 --> 看爷爷、父亲、和cur的相对位置来决定用什么旋转，旋转后交换父亲和爷爷的颜色
cur=newNode;
while(parent &&  parent->_color == RED)
{
  // 既然进来了这个循环内部，说明父亲一定是红色，那么一定有爷爷且爷爷颜色为黑
  Node* grandfather = parent->_parent;
  // 确定叔叔的位置
  if(grandfather->_left == parent)
  {
    Node* uncle=grandfather->_right;
    if(uncle && uncle->_color == RED)// 叔叔存在且为红
    {
      parent->_color=uncle->_color=BLACK;
      grandfather->_color=RED;
      cur=grandfather;
      parent=cur->_parent;
    }
    else // 叔叔不存在或者存在且为黑
    {
      if(cur == parent->_right)
      {
        RotateL(parent);
        std::swap(parent,cur);
      }
      RotateR(grandfather);
      parent->_color=BLACK;
      grandfather->_color=RED;
      break;
    }
  }
  else if(grandfather->_right == parent)
  {
    Node* uncle=grandfather->_left;
    if(uncle && uncle->_color==RED)// 叔叔存在且为红
    {
      uncle->_color=parent->_color=BLACK;
      grandfather->_color=RED;
      cur=grandfather;
      parent=cur->_parent;
    }
    else // 叔叔不存在或存在且为黑
    {
      if(cur == parent->_left)
      {
        RotateR(parent);
        std::swap(parent,cur);
      }
      RotateL(grandfather);
      parent->_color=BLACK;
      grandfather->_color=RED;
      break;
    }
  }
}
_root->_color=BLACK;
}

// 左单旋
void RotateL(Node* parent)
{
  Node* subR=parent->_right;
  Node* subRL=subR->_left;
  parent->_right=subRL;
  if(subRL != nullptr)
  {
    subRL->_parent=parent;
  }
  subR->_left=parent;
  Node* pparent=parent->_parent;
  parent->_parent=subR;
  if(pparent == nullptr)
  {
    _root=subR;
    subR->_parent=nullptr;
  }
  else 
  {
    subR->_parent=pparent;
    if(pparent->_left == parent)
    {
      pparent->_left=subR;
    }
    else if(pparent->_right == parent)
    {
      pparent->_right=subR;
    }
  }
}

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

  parent->_left=subLR;
  if(subLR != nullptr)
  {
    subLR->_parent=parent;
  }
  subL->_right=parent;
  Node* pparent=parent->_parent;
  parent->_parent=subL;
  if(pparent == nullptr)
  {
    _root=subL;
    subL->_parent=nullptr;
  }
  else 
  {
    subL->_parent=pparent;
    if(pparent->_left == parent)
    {
      pparent->_left=subL;
    }
    else if(pparent->_right == parent) 
    {
      pparent->_right=subL;
    }
  }

3.3 调整总结

在这里插入图片描述

4. 完整代码

#pragma once

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::pair;

// 枚举定义颜色
enum COLOR
{
  RED,
  BLACK
};

// 节点的定义
template<class k, class v>
struct RBTreeNode
{
  // 构造函数，颜色默认给为红色
  RBTreeNode(const pair<k, v>& kv)
    :_color(RED)
    ,_kv(kv)
    ,_parent(nullptr)
    ,_left(nullptr)
    ,_right(nullptr)
  {}

  COLOR _color;
  pair<k, v> _kv;
  RBTreeNode<k, v>* _parent;
  RBTreeNode<k, v>* _left;
  RBTreeNode<k, v>* _right;
};

// 树的定义
template<class k, class v>
class RBTree 
{
  public:
    typedef RBTreeNode<k, v> Node;

    // 插入一个节点
    bool Insert(const pair<k, v>& kv)
    {
      // 第一步：按搜索树规则插入一个节点
      // 1、空树的话插入节点作为根节点
      // 2、不空的话，按搜索树规则找到插入的位置，然后插入
      if(!_root)
      {
        _root=new Node(kv);
        _root->_color=BLACK;
        return true;
      }
      // 寻找插入的位置
      Node* parent=nullptr;
      Node* cur=_root;
      while(cur)
      {
        parent=cur;
        if(cur->_kv.first == kv.first)
        {
          return false;
        }
        else if(cur->_kv.first < kv.first)
        {
          cur=cur->_right;
        }
        else if(cur->_kv.first > kv.first)
        {
          cur=cur->_left;
        }
      }
      // 找到后插入
      Node* newNode=new Node(kv);
      newNode->_parent=parent;
      if(parent->_kv.first > kv.first)
      {
        parent->_left=newNode;
      }
      else if(parent->_kv.first < kv.first) 
      {
        parent->_right=newNode;
      }
      // 第二步：调整节点的颜色
      // 1、如果父亲颜色为黑就不用调整
      // 2、如果父亲节点颜色为红，调整方式由叔叔决定
      //    a、叔叔存在且为红 --> 把叔叔和父亲的颜色调整为黑，爷爷颜色调整为红，然后继续往上调整
      //    b、叔叔不存在或存在且为黑 --> 看爷爷、父亲、和cur的相对位置来决定用什么旋转，旋转后交换父亲和爷爷的颜色
      cur=newNode;
      while(parent &&  parent->_color == RED)
      {
        // 既然进来了这个循环内部，说明父亲一定是红色，那么一定有爷爷且爷爷颜色为黑
        Node* grandfather = parent->_parent;
        // 确定叔叔的位置
        if(grandfather->_left == parent)
        {
          Node* uncle=grandfather->_right;
          if(uncle && uncle->_color == RED)// 叔叔存在且为红
          {
            parent->_color=uncle->_color=BLACK;
            grandfather->_color=RED;
            cur=grandfather;
            parent=cur->_parent;
          }
          else // 叔叔不存在或者存在且为黑
          {
            if(cur == parent->_right)
            {
              RotateL(parent);
              std::swap(parent,cur);
            }
            RotateR(grandfather);
            parent->_color=BLACK;
            grandfather->_color=RED;
            break;
          }
        }
        else if(grandfather->_right == parent)
        {
          Node* uncle=grandfather->_left;
          if(uncle && uncle->_color==RED)// 叔叔存在且为红
          {
            uncle->_color=parent->_color=BLACK;
            grandfather->_color=RED;
            cur=grandfather;
            parent=cur->_parent;
          }
          else // 叔叔不存在或存在且为黑
          {
            if(cur == parent->_left)
            {
              RotateR(parent);
              std::swap(parent,cur);
            }
            RotateL(grandfather);
            parent->_color=BLACK;
            grandfather->_color=RED;
            break;
          }
        }
      }
      _root->_color=BLACK;
    }

 private:
    // 左单旋
    void RotateL(Node* parent)
    {
      Node* subR=parent->_right;
      Node* subRL=subR->_left;
      parent->_right=subRL;
      if(subRL != nullptr)
      {
        subRL->_parent=parent;
      }
      subR->_left=parent;
      Node* pparent=parent->_parent;
      parent->_parent=subR;
      if(pparent == nullptr)
      {
        _root=subR;
        subR->_parent=nullptr;
      }
      else 
      {
        subR->_parent=pparent;
        if(pparent->_left == parent)
        {
          pparent->_left=subR;
        }
        else if(pparent->_right == parent)
        {
          pparent->_right=subR;
        }
      }
    }

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

      parent->_left=subLR;
      if(subLR != nullptr)
      {
        subLR->_parent=parent;
      }
      subL->_right=parent;
      Node* pparent=parent->_parent;
      parent->_parent=subL;
      if(pparent == nullptr)
      {
        _root=subL;
        subL->_parent=nullptr;
      }
      else 
      {
        subL->_parent=pparent;
        if(pparent->_left == parent)
        {
          pparent->_left=subL;
        }
        else if(pparent->_right == parent) 
        {
          pparent->_right=subL;
        }
      }
    }

    Node* _root=nullptr;
};
Luojj_2020
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树（C++实现）
2021dragon的博客
12-06 1万+
红黑树（C++实现）
【数据结构】红黑树模拟实现
m0_62572672的博客
12-30 156
红黑树的底层可以看作是AVL树的变种。先前我们了解过AVL的模拟实现。avl对整棵树的控制还是非常严格的，因为高度差不能大于2，导致会经常发生旋转。旋转这个过程也会降低效率，所以为了整体的效率衍生出了红黑树。红黑树旋转的没有那么频繁。红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。红黑树的节点没有平衡因子，由颜色替代，红色和黑色。红黑树的实现是由四条规则实现的当满足这四条规则时，这棵树自然而然就是红黑树了。因为每条路径的黑色节点数是相同的，所以不同路径的节点数的差别一定在于红色节点数的不同。
红黑树介绍与模拟实现（insert+颜色调整精美图示超详解哦）
weixin_73450183的博客
04-04 1649
红黑树是平衡二叉树的一种，他在满足二叉搜索树特性的基础上，给每个结点增加了一个颜色属性，包括Red与Black；并要求从根节点到一个叶子结点形成的任意一条路径中，通过对结点颜色的限制规则，没有任何一条路径回比其他的路径长一倍
C++语法（20）---- 模拟红黑树
竹杖芒鞋轻声马
04-22 791
模拟红黑树含代码实现
红黑树的模拟实现
CL2426的博客
09-06 265
图片仅供相应场景。
红黑树+红黑树模拟实现map/set
cxy_zjt的博客
11-07 532
红黑树 1.红黑树相关概念 (1).红黑树的性质 2. 红黑树核心代码实现 **(1).红黑树结点的定义** (2)插入的几种情况 Ⅰ插入的条件判断 a.cur为红，p为红，u存在且为红 b.cur为红，p为红，u不存在/存在且为黑 3. 红黑树和AVL树的比较 红黑树模拟实现map/set 1.红黑树迭代器的实现 (1).迭代器的++与-- (2)洪恩红黑树中的begin（）和end（） 2.改造红黑树 a.begin()和end() b.pairinsert(const
map和set的模拟实现
最新发布
06-06
封装红黑树，模拟SLT源码实现，封装出map和set
14、(CSP-S) 提高级 C++ 语言试题 海亮内部模拟卷-答案.pdf
10-08
红黑树是平衡树的一种。 5. 组合数（nk）为从 n 件有标号物品中选出 k 件物品的方案数，例如（32）= 3。下列说法错误的为：C(nk) ≠ (n−1k) + (n−1k−1)。 6. CPU 的用途是将计算机系统所需要的显示信息进行转换...
c/c++二叉树详解，作业，学习参考
12-04
学习数据结构的C++源码，包含AVL树、Treap、多个有序链表合并、二叉查找树、二项堆、红黑树、伸展树、跳表、栈与队列相互模拟以及最小(大)值求解，可做参考学习
RB_Tree.rar_数据结构_Visual_C++_
08-12
红黑树的算法模拟。红黑树的生成，结点的插入、删除和调整。通过类的方式管理。
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
1.4 C＋＋程序的编写和实现 1.5 关于C＋＋上机实践 习题 第2章 数据类型与表达式 2.1 C＋＋的数据类型 2.2 常量 2.2.1 什么是常量 2.2.2 数值常量 2.2.3 字符常量 2.2.4 符号常量 2.3 变量 2.3.1 什么是变量 2.3.2 ...
AVL树与红黑树实现（可视化界面）
03-14
本人实现的 AVL树与红黑树，具有可视化界面，代码清晰。
红黑树程序（用C++实现）
01-12
红黑树的C++实现，包括红黑树的插入，删除，查找等操作
rbtrees:红黑树的旧 C++ 实现
07-14
树 红黑树的旧 C++ 实现 线程安全红黑树的 C++ 实现，不使用 STL，完全没有外部依赖。 该实现是通用且高效的。 插入 100 万个 int32_t 键节点需要 521 毫秒，而从 100 万个节点树中检索需要 2 毫秒！！ 编译，签出并运行make 。 注意您必须安装 gtest 才能运行测试套件
[C++] 红黑树（RBTree）的模拟实现
giturtle's blog
07-26 346
代码实现 #pragma once enum Colour{ RED, BLACK, }; template<class T> struct RBtreeNode{ RBtreeNode<T>* _left; RBtreeNode<T>* _right; RBtreeNode<T>* _parent; T _val; Col...
[C++]---红黑树性质及简单模拟实现
夜微雨的博客
05-09 282
红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，一般是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，从而确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色，根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的，也就是 红色节点不能连续，黑色节点可以连续。 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点。 每个叶子结点都是黑色的(此处
数据结构模拟器
shumoyin的博客
12-12 4772
数据结构模拟器：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
推荐一个好用的线上画算法图的实现（B树、栈、红黑树……）
强哥叨逼叨
06-21 5639
地址：点击打开链接
红黑树的删除—10张图学会
热门推荐
早就戒了的博客
12-23 1万+
如果要学红黑树，那么就必须知道二叉树，毕竟红黑树本身就是一个二叉搜索树。只不过红黑树比一般的二叉搜索树更加稳定，也就是更加平衡，但是有没有AVL树那么的稳定，这换来的是红黑树比AVL数有更好的插入和删除效率，但是查找效率并没有比AVL差很多。下文我将用RBT代替红黑树。二叉搜索树的删除介绍RBT的删除，就先要知道二叉搜索树的删除(知道的同学可以直接跳过)。删除分为四步： 1.找到删除点假设为X
c++红黑树用什么实现
05-28
在 C++ 中，可以使用指针和结构体来实现红黑树。具体来说，可以定义一个 `Node` 结构体来表示树中的每个节点，结构体中包含节点的值、颜色（红色或黑色）、左子树、右子树和父节点等信息。同时，可以定义一个 `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值