数据结构——红黑树

最新推荐文章于 2024-08-05 10:05:05 发布
最新推荐文章于 2024-08-05 10:05:05 发布
阅读量230 收藏
点赞数
分类专栏： 树 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38933606/article/details/120677350
版权

1.红黑树是什么？

红黑树首先是一棵自平衡二叉查找树。它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树（AVL），但 对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。
它具有以下的特性：

  • 节点颜色非红即黑
  • 根节点黑色
  • 叶子节点黑色(空节点)
  • 红色节点不能连续
  • 节点到空节点的任意路径黑色节点个数相同

2.原理

2.1、左旋和右旋

如下图所示，设失衡节点为S，父节点为P，父节点为G，P兄弟节点为B。
1）满足特性(4)，将P涂黑；此时左侧黑色长度加一。
2）满足特性(5)，将G涂红；此时右侧黑色长度减一。
3）满足特性(5)，以P为中心向右旋转；；此时红黑树平衡。

在这里插入图片描述

2.1、添加节点

首先，按照二叉树的原理，插入新节点。
设失衡节点为S，父节点为P，祖父节点为G，P兄弟节点为B。
则插入的基本流程如下：
1）判断是否根节点
2）判断父节点颜色
3）判断父节点属于祖父节点的哪一个分支
4）判断失衡节点属于祖父节点的哪一个分支
在这里插入图片描述

2.2、删除节点

首先，按照二叉树的原理，删除指定节点S。
设失衡节点为S（S = P->L），父节点为P，兄弟节点为B。
则插入的基本流程如下：
1）判断是否存在左节点
2）判断是否存在右节点
3）判断节点颜色
4）判断兄弟节点的右节点颜色
5）判断兄弟节点的左节点颜色
6）判断父节点颜色
在这里插入图片描述

3.示例

简单实现

enum RBColor { RED, BLACK };

template <class K, class V>
class RBTree {
 private:
  class RBNode {
   private:
    friend class RBTree;
    K key;
    V val;
    RBColor color;
    RBNode *l;
    RBNode *r;
    RBNode *p;

   public:
    RBNode(RBNode *parent, K key, V data) : p(parent), key(key), val(data) {
      this->l = this->r = nullptr;
      if (this->p == nullptr)
        this->color = BLACK;  // 2)
      else
        this->color = RED;  // 5)
    }
    ~RBNode() { ; }
  };

  void DelNode(RBNode *node) {
    if (node != nullptr) {
      DelNode(node->l);
      DelNode(node->r);
      delete node;
    }
  }

  bool isRed(RBNode *node) {
    if (node == nullptr) return false;
    if (node->color == RED)
      return true;
    else
      return false;
  }

  RBNode *ReColor(RBNode *node) {
    if (node != root) node->color = RED;
    node->l->color = node->r->color = BLACK;
    return node;
  }

  RBNode *ReColor(RBNode *node, bool left) {
    node->color = RED;
    if (left)
      node->l->color = BLACK;
    else
      node->r->color = BLACK;
    return node;
  }

  RBNode *LL(RBNode *node) {
    RBNode *_new = node->l;
    // 更新子节点信息
    node->l = _new->r;
    if (node->l != nullptr) node->l->p = node;
    _new->r = node;
    // 更新父节点信息
    _new->p = node->p;
    node->p = _new;
    return _new;
  }

  RBNode *RR(RBNode *node) {
    RBNode *_new = node->r;
    node->r = _new->l;
    if (node->r != nullptr) node->r->p = node;
    _new->l = node;
    _new->p = node->p;
    node->p = _new;
    return _new;
  }

  /*
   * 红黑树插入存在3种情形：(1,2不需要特殊处理)
   * 1) 插入根节点
   * 2) 父节点黑色
   * 3) 父节点/叔叔红色, 祖父节点黑色
   *    3)递归后, 出现以下情形：
   *    3-1) 父节点黑色, 同2)
   *    3-2) 父节点/叔叔红色, 祖父节点黑色, 同3)
   *    3-3) 父节点红色, 叔叔节点/祖父节点黑色
   */
  RBNode *add(RBNode *parent, RBNode *node, K key, V data, int &weight) {
    if (node == nullptr) {
      weight = 3;
      return new RBNode(parent, key, data);
    }
    if (key < node->key) {
      node->l = add(node, node->l, key, data, weight);
      if (weight) {
        weight = (weight == 3) ? -3 : weight;
        weight = weight - 1;
      }
    } else if (key > node->key) {
      node->r = add(node, node->r, key, data, weight);
      weight = (weight == 0) ? weight : weight + 1;
    }

    return rebalance(node, weight);
  }

  RBNode *get(RBNode *node, K key) {
    if (node == nullptr) return nullptr;
    if (node->key == key)
      return node;
    else if (key < node->key)
      return get(node->l, key);
    else
      return get(node->r, key);
  }

  RBNode *Max(RBNode *node) {
    while (node->r != nullptr) {
      node = node->r;
    }
    return node;
  }

  RBNode *rebalance(RBNode *node, int &weight) {
    switch (weight) {
      case -5:  // 此时左子树红色长度加1
      case 3:
        if ((node->l->l != nullptr && isRed(node->l->l)) ||
            (node->l->r != nullptr && isRed(node->l->r))) {
          if (isRed(node->l)) {
            if (isRed(node->r))  // 插入情形3-2)
            {
              node = ReColor(node);
              weight = 3;
              break;
            } else {                                   // 插入情形3-3)
              if (weight == 3) node->l = RR(node->l);  // 转换为ll情形
              node = ReColor(node, true);              // 解决特性4)
              node = LL(node);                         // 解决特性5)
            }
          }
        }
        weight = 0;
        break;
      case 5:  // 此时右子树红色长度加1
      case -3:
        if ((node->r->r != nullptr && isRed(node->r->r)) ||
            (node->r->l != nullptr && isRed(node->r->l))) {
          if (isRed(node->r)) {
            if (isRed(node->l))  // 情形3-2)
            {
              node = ReColor(node);
              weight = 3;
              break;
            } else {                                    // 情形3-3)
              if (weight == -3) node->r = LL(node->r);  // 转换为rr情形
              node = ReColor(node, false);              // 解决特性4)
              node = RR(node);                          // 解决特性5)
            }
          }
        }
        weight = 0;
        break;
      // 此时左子树黑色长度减1
      case -2:
        /*
         * 设当前节点的左右子树的黑色节点长度L=R=n
         * 此时，左子树L=n-1,R=n
         * 为使左右平衡，存在2个方案：
         *  1）通过旋转将右子黑色节点转移到左子树，同时将一个红色节点涂黑。
         *  2）将右子树的一个黑色节点涂红，向上递归。
         */
        if (node->r->r != nullptr && isRed(node->r->r)) {  // 方案1)
          node = RR(node);
          // 交换父节点和右节点颜色
          node->color = node->l->color;
          node->l->color = BLACK;
          // 涂黑红色颜色
          node->r->color = BLACK;
          // 平衡常数置零
          weight = 0;
        } else if (node->r->l != nullptr && isRed(node->r->l)) {  // 方案1)
          node->r = LL(node->r);
          node = RR(node);
          // 交换父节点和右节点颜色
          node->color = node->l->color;
          node->l->color = BLACK;
          // 涂黑红色颜色
          node->r->color = BLACK;
          // 平衡常数置零
          weight = 0;
        } else if (isRed(node->r)) {
          node = RR(node);
          // 交换父节点和右节点颜色
          node->color = BLACK;
          node->l->color = RED;
          node->l = rebalance(node->l, weight);
        } else if (isRed(node->r) == false) {  // 右节点和右子节点均为黑色
          node->r->color = RED;
          if (isRed(node)) {  // 父节点红色
            node->color = BLACK;
            weight = 0;
          } else {  // 父节点黑色 方案2)
            weight = -1;
          }
        }
        break;
      case 2:  // 右子树黑色长度减1
        if (node->l->l != nullptr && isRed(node->l->l)) {  // 方案1)
          node = LL(node);
          // 交换父节点和右节点颜色
          node->color = node->r->color;
          node->r->color = BLACK;
          // 涂黑红色颜色
          node->l->color = BLACK;
          // 平衡常数置零
          weight = 0;
        } else if (node->l->r != nullptr && isRed(node->l->r)) {  // 方案1)
          node->l = RR(node->l);
          node = LL(node);
          // 交换父节点和右节点颜色
          node->color = node->r->color;
          node->r->color = BLACK;
          // 涂黑红色颜色
          node->l->color = BLACK;
          // 平衡常数置零
          weight = 0;
        } else if (isRed(node->l)) {
          node = LL(node);
          // 交换父节点和右节点颜色
          node->color = BLACK;
          node->r->color = RED;
          node->r = rebalance(node->r, weight);
        } else if (isRed(node->l) == false) {  // 节点和子节点均为黑色
          node->l->color = RED;
          if (isRed(node)) {  // 父节点红色
            node->color = BLACK;
            weight = 0;
          } else {  // 父节点黑色 方案2)
            weight = -1;
          }
        }
        break;
      default:
        break;
    }
    return node;
  }

  /*
   * 红黑树插入存在4种情形：
   * 1) 叶子节点
   * 2) 存在左子树
   *    2-1) 删除节点红-子节点黑, 不符合特性5)
   *    2-2) 删除节点黑-子节点红
   * 3) 存在右子树
   *    3-1) 删除节点红-子节点黑, 不符合特性5)
   *    3-2) 删除节点黑-子节点红
   * 4）存在左右子树, 用前驱节点(K,V)替换删除节点，转变为删除前驱节点。1) 2)
   */
  RBNode *remove(RBNode *node, K key, int &weight) {
    if (node == nullptr) return nullptr;

    RBNode *_new = nullptr;
    if (key < node->key) {
      node->l = remove(node->l, key, weight);
      _new = node;
      weight = (weight == -1) ? -2 : 0;  //
    } else if (key > node->key) {
      node->r = remove(node->r, key, weight);
      weight = (weight == -1) ? 2 : 0;  //
      _new = node;
    } else {
      if (node->l == nullptr) {
        _new = node->r;
        if (_new != nullptr) {  // 3-2)
          _new->p = node->p;
          _new->color = BLACK;
        } else if (node->color == BLACK) {
          weight = -1;  // 1) 删除节点为黑
        } else {
          ;  // 1) 当前节点为红
        }
      } else if (node->r == nullptr) {
        _new = node->l;  // 2-2)
        _new->p = node->p;
        _new->color = BLACK;
      } else {  // 4)
        _new = Max(node->l);  // 在左子树寻找前驱节点
        _new->l = remove(node->l, _new->key, weight);
        _new->p = node->p;
        _new->r = node->r;
        _new->color = node->color;
        if(_new->l != nullptr)
          _new->l->p = _new;
        if(_new->r != nullptr)
          _new->r->p = _new;
        weight = (weight == -1) ? -2 : 0;
      }
    }

    return rebalance(_new, weight);
  }

  RBNode *root;

#ifdef _DEBUG
  int Check(RBNode *node) {
    if (node == nullptr)
      return 1;
    else {
      if (isRed(node) && isRed(node->p)) return -1;
      if (node->l != nullptr && node != node->l->p) return -1;
      if (node->r != nullptr && node != node->r->p) return -1;
      int left = Check(node->l);
      int right = Check(node->r);
      if (left == -1 || right == -1 || left != right) return -1;
      if (node->color == RED)
        return left;
      else
        return left + 1;
    }
  }
#endif

 public:
  RBTree() { root = nullptr; }

  ~RBTree() { DelNode(root); }

  void add(K key, V data) {
    RBNode *node = get(root, key);
    if (node != nullptr) return;
    int weight = 0;
    root = add(root, root, key, data, weight);
  }

  V get(int key) {
    RBNode *node = get(root, key);
    if (node != nullptr) return node->val;
    return nullptr;
  }

#ifdef _DEBUG
  int Check() { return Check(root); }
#endif

  V remove(int key) {
    RBNode *node = get(root, key);
    if (node == nullptr) return 0;
    V val = node->val;
    int weight = 0;
    root = remove(root, key, weight);
    delete node;
    return val;
  }
};
摩尔の
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 - 红黑树
从零开始
01-17 3198
数据结构 - 红黑树 - 面试常问知识点 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍树中的常见的红黑树数据结构。包括 简介 应用 左旋和右旋 简介 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的
内存中最优的数据结构——红黑树
m0_53199081的博客
11-30 482
目录 一、首先先来了解什么是2-3-4树 1.简介 2.三种节点的示意图 3.构建一颗2-3-4树 二、红黑树 1.认识红黑树的特性 2.从2-3-4树到红黑树 一、首先先来了解什么是2-3-4树 1.简介 2-3-4属于一种多路查找树，是一种四阶的B树，它的结果有以下特点 所有叶子节点都拥有相同的深度 节点只能是2-节点、3-节点、4-节点节点 元素的排序整体上保持二叉查找树的特性,即父节点大于左子节点，小于右子节点；当节点有多个元素时，每个元素都必须大于..
数据结构：红黑树（Red Black Tree）
Gabriel.Tian的博客
07-29 503
概念 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。它可以在O(log n)时间内（它的查找最坏时间复杂度为O(2lgn)）做查找，插入和删除，这里的n 是树中元素的数目。 性质 节点是红色或黑色。 根节点是黑色...
『数据结构』红黑树
叄拾叄画生
07-26 224
什么是红黑树？红黑树的性质。红黑结点的定义。红黑树的插入操作。红黑树的验证。红黑树和AVL树的比较。
基础介绍-红黑树-数据结构
gaogzhen的博客
06-26 292
基础介绍-红黑树-数据结构 目录 文章目录一、简介二、特征三、时间复杂度 内容 一、简介   红黑树是一种特定类型的二叉树，它是在计算机科学中用来组织数据比如数字的块的一种结构。   红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树（AVL），但 对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。   由于每一棵红黑树都是一颗二叉排序树，因此，在对红黑树进行查找时，可以采用运用于普通二叉排序树上的查找算法，在查找过程中不需要颜色信息。
通俗易懂的数据结构——红黑树
最新发布
Elean_ding的博客
08-05 635
相信真正热爱java的开发者们，都读过java版的数据结构和算法，还没读过的java粉们，也在买书和搜索资料的路上（想找还没找到的小伙伴们，也可以@Elean说“我要”）。大家都知道，在实际开发中，HashMap的应用场景很常见，因此，它也成了招聘中很多面试官的钟爱。如果你说，你对它的底层原理没有做深入了解还好，但如果你说有看过，那么不好意思，你入坑了，挖呀挖呀挖呀，总会给你挖出个“红黑树”。强扭的瓜不甜，硬记的脸易忘。
GO数据结构——红黑树（一.基础操作）
qq_53057924的博客
09-23 1057
1.简介 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。在开发当中，红黑树的综合效率最高，复杂度也最高。 红黑树的特性: （1）每个节点或者是黑色，或者是红色。（红色代表true，黑色代表false） （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。[注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点] （4）如果一个节点是红色的，则它的子节点必须是黑色的
数据结构之红黑树（RBTree）
Tlzns的博客
11-13 363
数据结构之红黑树（RBTree）
数据结构-红黑树（超详细，强烈推荐！！）
DChuan
01-09 1511
(一) 基本概念 Red-Black Tree 称为“红黑树”，是一种自平衡二叉查找树，红黑树和 AVL 树类似，在进行插入和删除时需要通过旋转和重新着色来维持其红黑树的特性。 红黑树的应用相当广泛，主要是用它来存储有序的数据，它的时间复杂度为 O(logn)，查询效率非常高。 1. 红黑树和 AVL 树的区别： 红黑树并不追求“完全平衡” —— 它只要求部分地达到平衡要求，降低了对旋转的要求，
java数据结构与算法总结(三)--漫画：什么是红黑树
秋天的猿
05-20 279
本文来自 接下来先讲一下什么是左旋转！通过动画举个例子吧！ 人生像红黑树一样，总是需要某种平衡 一边是给予，一边是接受 一边是付出，一边是得到 一边是耕耘，一边是收获 一边是物质，一边是精神 阿广你年过二十而未立 置身于五光十色的世俗社会 我希望阿广都能铭记 一个古老但不失色彩的道理！ “活...
C++数据结构与算法（红黑树）
鄠邑原野的博客
08-15 365
前情回顾：一棵高度为h的二叉搜索树，它可以支持任何一种基本动态几何操作，如查找、插入、删除等，其时间复杂度为O(h)。因此，如果搜索树的高度较低时，这些集合操作会执行得较快。然而，如果树的高度较高，这些集合操作可能比链表慢。红黑树（red-black tree）是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为O(logn)。 Q1：什么是红黑树？ ...
红黑树（一）：基本概念和数据结构
主要研究图形学相关领域
05-31 204
红黑树（一）：基本概念和数据结构
什么是红黑树?
然而老干妈早就看穿了一切
11-03 305
先理解二叉查找树(Binary Search Tree): 二叉查找树(BST)具备特点: 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 距离查找10的节点: 1.查看根节点9： 2.由于10 > 9，因此查看右孩子13： 3
红黑树原理
Flippeds的博客
12-01 271
一.简介 红黑树作为一种二叉搜索树的一种实现，红黑树的左右子树高度差可能大于 1。所以红黑树不是严格意义上的平衡二叉树（AVL），但红黑树是黑色节点完美平衡， 其平均统计性能要强于 AVL 。 红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。 1.节点是红色或黑色。 2.根节点是黑色。 3.每个红色节点的两个子节点都是黑色。（红色节点的子节点必须是黑色节点） 4.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 故红黑树是黑色平衡的树，左子树与右子树高度差不会超过2倍。红节点的父节点
红黑树
Zllvincent的博客
06-07 2359
1.简介 红黑树作为一种二叉搜索树的一种实现，红黑树的左右子树高度差可能大于 1。所以红黑树不是严格意义上的平衡二叉树（AVL），但 对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。 红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。 1.节点是红色或黑色。 2.根节点是黑色。 3.每个红色节点的两个子节点都是黑色。（从每个叶子到根的所有路径上不能有两个连续的红色节点） 4.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 故红黑树是黑色平衡的树 如果插入节点是黑色则所在路径
浅谈红黑树
weixin_60589106的博客
01-13 531
树：红黑树
zp_zhang的博客
07-18 215
1，红黑树引入 红黑树是对AVL树的补充。AVL树要求整个树的高度差不能超过1，超过后需要进行左旋或者右旋操作再次对树进行平衡，虽然这样能够解决二叉树退化为链表的缺点，将查询的时间复杂度控制在O(logN)，但却不是最佳的；因为AVL树对高度差的控制太严，在需要频繁进行插入/删除的场景中，AVL需要频繁进行树平衡调整，影响整体性能，为了解决这个问题，引入红黑树 2，红黑树性质 性质1：每个节点要么是黑色，要么是红色 性质2：根节点是黑色 性质3：每个叶子节点(NIL)是黑色，NIL表示虚拟节点 性质4
Linux实验：数据结构实现——红黑树与堆排序
本篇文章主要介绍了在Linux环境下，通过DevC++编程实现的数据结构实验项目，重点涉及了堆排序算法以及红黑树的数据结构。实验者丛培钰首先构建了一个简单的菜单系统，用户可以通过选择不同的数字来运行不同的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值