红黑树详细笔记

已于 2022-02-07 17:19:09 修改
阅读量850 收藏 1
点赞数
分类专栏： 图论 文章标签： 算法 数据结构 b树
于 2022-02-07 17:15:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52185313/article/details/122811330
版权

红黑树、2-3-4树 – 潘登同学的图论笔记

文章目录

2-3-4树

红黑树是2-3-4树的一种实现形式，只是2-3-4树的编程不太好写，但是2-3-4树的思想还是比较简洁明了滴…

2-3-4树

2-3-4树是四阶的balance tree，他属于一种多叉查找树

有如下要求

  • 1.所有叶子节点都拥有相同的深度
  • 2.节点只能是2-节点，3-节点，4-节点之一
  • 3.2-节点：包含一个元素的节点，有2个子节点
  • 3-节点：包含两个元素的节点，有3个子节点
  • 4-节点：包含三个元素的节点，有4个子节点
  • 4.元素始終保持排序順序，整体上保持二叉查找树的性质，即父节点大于左子节点，小于右子节点
  • 5.而节点有多个元素时，每个元素必须大于他左边的和他的左子树中元素

通过一个2-3-4树的生成过程来加深对他的认识

2-3-4树生成过程1

2-3-4树生成过程2

2-3-4树生成过程3

2-3-4树生成过程4

2-3-4树生成过程5

2-3-4树生成过程6

2-3-4树生成过程7

简单概况一下2-3-4树的生成过程： 在叶节点添加元素，如果叶节点超过了三个元素（如4个元素），那么第二个元素就会上升，其余分裂成一个二节点和一个三节点

总之，在叶节点上添加，然后多了就上升分裂，这样能保持树的高度是趋于一致的

红黑树

红黑树也是二叉树，与AVL树类似，但是平衡性不如AVL树要好，要经过很多次插入和删除才会更新一次，有如下要求

  • 1.根节点一定是黑色，叶节点是不存储数据的黑色空节点
  • 2.红节点的子节点必须是黑色的
  • 3.对任意节点，走到叶节点(空节点)路径上遇到的黑节点个数一样
  • 4.由前三条推出 红黑树的高度最高是 2*log_2(n+1) n是节点个数

红黑树与2-3-4树的对应关系

  • 2-节点： 黑色节点

红黑树与2-3-4树对应关系

  • 3-节点: 左倾或者右倾

红黑树与2-3-4树对应关系

  • 4-节点: 对应一个完整的叉

红黑树与2-3-4树对应关系

注意 上面的都是上黑下红

  • 裂变状态

当在10-11-12中加入节点13，可以理解为 10-11-12节点集体上升然后变色，如果11是根节点，那么将会变回黑色

红黑树与2-3-4树对应关系

红黑树节点

红黑树节点有这样几个属性:

  • 1.val: 节点储存的值
  • 2.left: 左子节点
  • 3.right: 右子节点
  • 4.color: 节点颜色
  • 5.parent: 父节点

伴随着的有如下节点方法:

  • 1.hasleft: 判断是否有左子节点
  • 2.hasright: 判断是否有右子节点
  • 3.isleft: 判断节点是否为左子节点
  • 4.isright: 判断节点是否为右子节点
  • 5.isroot: 判断节点是否为根节点
  • 6.getcolor: 获取节点颜色
  • 7.setcolor: 设置节点颜色
  • 8.getparent: 获取父节点
  • 9.str 显示设置
  • 10.iter 遍历设置
  • 11.search: 查找操作

上代码

class RBTreeNode:
    def __init__(self,val=None,left=None,right=None,color='black',parent=None):
        self.left = left
        self.right = right
        # color = 'red' or 'black'
        self.color = color
        self.parent = parent
        self.val = val

    def hasleft(self):
        return self.left

    def hasright(self):
        return self.right

    def isleft(self):
        return self.parent and self.parent.left == self

    def isright(self):
        return self.parent and self.parent.right == self

    def isroot(self):
        return not self.parent

    def getcolor(self):
        return self.color

    def getparent(self):
        return self.parent

    def setcolor(self,color):
        self.color = color

    def __str__(self):
        return '数据是:{}'.format(self.val) 
    
    def __iter__(self):
        if self:
            if self.hasleft():
                # 递归调用
                for elem in self.left:
                    yield elem
            yield self.val  # 把根节点放在中间，最终的输出就是从小到大
            if self.hasright():
                # 递归调用
                for elem in self.right:
                    yield elem

    def search(self,val):
        '''
        :type val: number
        :rtype: RBTreeNode
        '''
        if self.val > val:
            return self.left.search(val) if self.left else None
        elif self.val == val:
            return self
        else:
            return self.right.search(val) if self.right else None

红黑树

红黑树基础的有两个属性

  • 1.root: 存储根节点
  • 2.size: 记录节点数

两个基本方法:

  • 1.len 查看树的节点数
  • 2.iter 树的遍历(前序遍历，从小到大)
class RBTree:
    def __init__(self):
        self.root = None
        self.size = 0

    def __len__(self):
        return self.size

    def __iter__(self):
        return self.root.__iter__()

红黑树的插入操作

红黑树的插入分为两步

  • 1.普通二叉树的插入
  • 2.红黑树的平衡(旋转 + 变色)

先写旋转（左旋、右旋）操作，这个在AVL中也有，基本上是一样的

    # 左旋操作
    def leftRotate(self,rotRoot):
        '''
        :type rotRoot: RBTreeNode
        '''
        newRoot = rotRoot.right
        rotRoot.right = newRoot.left
        if newRoot.left:
            newRoot.left.parent = rotRoot
        newRoot.parent = rotRoot.parent
        if rotRoot.isroot():
            self.root = newRoot
        else:
            if rotRoot.isleft():
                rotRoot.parent.left = newRoot
            else:
                rotRoot.parent.right = newRoot
        newRoot.left = rotRoot
        rotRoot.parent = newRoot

    # 右旋操作
    def rightRotate(self,rotRoot):
        '''
        :type rotRoot: RBTreeNode
        '''
        newRoot = rotRoot.left
        rotRoot.left = newRoot.right
        if newRoot.right:
            newRoot.right.parent = rotRoot
        newRoot.parent = rotRoot.parent
        if rotRoot.isroot():
            self.root = newRoot
        else:
            if rotRoot.isleft():
                rotRoot.parent.left = newRoot
            else:
                rotRoot.parent.right = newRoot
        newRoot.right = rotRoot
        rotRoot.parent = newRoot

再写插入put()

    def put(self,val):
        # 新增节点，分为两步
        #   1.普通二叉树的插入
        #   2.红黑树的平衡(旋转+变色)
        if self.root:
            self._put(val, self.root)
        else:
            self.root = RBTreeNode(val=val,color='black')
        self.size += 1

    def _put(self,val,currentNode):
        if val < currentNode.val:
            if currentNode.hasleft():
                # 如果有左节点就递归调用自身
                self._put(val, currentNode.left)
            else:
                currentNode.left = RBTreeNode(val=val, parent=currentNode)
                self.fixAfterput(currentNode.left)
        # 如果与某个节点相等那就不管他，直接return
        elif val == currentNode.val:
            return
        else:
            if currentNode.hasright():
                # 如果有右节点就递归调用自身
                self._put(val, currentNode.right)
            else:
                currentNode.right = RBTreeNode(val=val, parent=currentNode)
                self.fixAfterput(currentNode.right)

在插入put()操作中存在一个未定义的方法fixAfterput()，这个就是插入后调整的方法，需要分类讨论何时需要调整

对应回2-3-4树，有三类情况

  • 情况一: 2-节点 新增一个元素 直接合并为3-节点 --> 红黑树直接添加一个红色节点无需调整
  • 情况二: 3-节点 新增一个元素 合并为4-节点 --> 红黑树有6种情况，有两种不需要调整根左左、根右右 旋转一次 根左右 根右左 旋转两次

详细情况可以参考下图

  • 根左左

红黑树根左左

  • 根右右

红黑树根右右

  • 根左右

红黑树根左右

  • 根右左

红黑树根右左

  • 正常情况

在这里插入图片描述

对于根左左、根右右只需对中间节点进行一次左旋或右旋即可，对于根左右、根右右，也是对中间节点进行左旋或者右旋就变成了根左左、根右右，然后再来一遍就可以了

  • 情况三: 4节点 新增一个元素 4节点中间元素升级为父节点，新增元素和剩下元素合并 --> 红黑树:新增节点为红色, 爷爷节点是黑色.父节点和叔叔节点为红色 调整为 爷爷节点变为红色(如果是root则为黑色),父亲和叔叔节点变为黑色,

情况三会有这四种情况

红黑树情况三(1)

红黑树情况三(2)

红黑树情况三(3)

红黑树情况三(4)

因为红黑树的红色节点下面不能还是红色节点，所以需要做变色操作，具体来说是:插入节点变红，插入节点的父节点(包括叔叔节点)变黑，爷爷节点变红(如果爷爷节点是根节点，变回黑色)

红黑树情况三(4)修改过后应是这样

红黑树情况三(4)正确

而值得注意的是，由于爷爷节点从黑色变为红色，对于爷爷节点的父节点来说，爷爷节点就相当于一个新插入的节点，这个新插入的红色节点又可能会影响爷爷节点的父节点进而产生情况一、二、三，所以需要对爷爷节点做递归处理

综合以上8种情况，以新增节点在爷爷节点的左子节点还是右子节点下，一分为二，在以情况二(旋转)、三(变色)的不同操作一分为二，最后给出调整代码

def fixAfterput(self,node):
        node.setcolor('red')
        while node and not node.isroot() and node.parent.getcolor() == 'red':
            # 如果插入的节点的父节点是爷爷节点的左侧
            if node.parent == node.parent.parent.left:
                # 对满足条件的4中情况 一分为二进行处理
                # 判断是否有叔叔节点，如果叔叔节点是红色就做变色操作
                if node.parent.parent.hasright() and node.parent.parent.right.getcolor() == 'red':
                    # 将父亲和叔叔节点变为黑色,将爷爷节点变为红色
                    node.parent.setcolor('black')
                    node.parent.parent.right.setcolor('black')
                    node.parent.parent.setcolor('red')
                    # 将修改了颜色的这一组子、父、爷节点视作一个整体，
                    # 看成一个红色节点插入到爷爷的父节点中递归处理
                    node = node.parent.parent
                else:
                    # 如果是根左右，先对‘左’进行一次左旋，就变成根左左
                    if node == node.parent.right:
                        self.leftRotate(node.parent)
                        node = node.left
                    # 如果是根左左
                    # 将父节点变为黑色
                    # 在对爷爷节点变色变为红色，最后对爷爷节点进行右旋
                    node.parent.setcolor('black')
                    node.parent.parent.setcolor('red')
                    self.rightRotate(node.parent.parent)
            else:
                # 与上面刚好相反的4中情况
                if node.parent.parent.hasleft() and node.parent.parent.left.getcolor() == 'red':
                    # 将父亲和叔叔节点变为黑色,将爷爷节点变为红色
                    node.parent.setcolor('black')
                    node.parent.parent.left.setcolor('black')
                    node.parent.parent.setcolor('red')
                    # 将修改了颜色的这一组子、父、爷节点视作一个整体，
                    # 看成一个红色节点插入到爷爷的父节点中递归处理
                    node = node.parent.parent
                else:
                    # 如果是根右左，先对‘右’进行一次右旋，就变成根右右
                    if node == node.parent.left:
                        self.rightRotate(node.parent)
                        node = node.right
                    # 如果是根右右
                    # 将父节点变为黑色
                    # 在对爷爷节点变色变为红色，最后对爷爷节点进行左旋
                    node.parent.setcolor('black')
                    node.parent.parent.setcolor('red')
                    self.leftRotate(node.parent.parent)
        # 最后处理爷爷节点为根节点的情况
        self.root.setcolor('black')

测试代码

进行完插入操作我们肯定要看自己写的对不对，我们新建一个画图函数，将红黑树绘制出来

import matplotlib.pyplot as plt
import numpy as np
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

class Draw_RBTree:
    def __init__(self, tree):
        self.tree = tree
    
    def show_node(self, node, ax, height, index, font_size):
        if not node:
            return
        x1, y1 = None, None
        if node.left:
            x1, y1, index = self.show_node(node.left, ax, height-1, index, font_size)
        x = 100 * index - 50
        y = 100 * height - 50
        if x1:
            plt.plot((x1, x), (y1, y), linewidth=2.0,color='b')
        circle_color = "black" if node.getcolor()=='black' else 'r'
        text_color = "beige" if node.getcolor()=='black' else 'black'
        ax.add_artist(plt.Circle((x, y), 50, color=circle_color))
        ax.add_artist(plt.Text(x, y, node.val, color= text_color, fontsize=font_size, horizontalalignment="center",verticalalignment="center"))
        # print(str(node.val), (height, index))

        index += 1
        if node.right:
            x1, y1, index = self.show_node(node.right, ax, height-1, index, font_size)
            plt.plot((x1, x), (y1, y), linewidth=2.0, color='b')

        return x, y, index

    def show_rb_tree(self, title):
        fig, ax = plt.subplots()
        left, right = self.get_left_length(), self.get_right_length(), 
        height = 2 * np.log2(self.tree.size + 1)
        # print(left, right, height)
        plt.ylim(0, height*100 + 50)
        plt.xlim(0, 100 * self.tree.size + 100)
        self.show_node(self.tree.root, ax, height, 1, self.get_fontsize())
        plt.axis('off')
        plt.title(title)
        plt.show()
    
    def get_left_length(self):
        temp = self.tree.root
        len = 1
        while temp:
            temp = temp.left
            len += 1
        return len
    
    def get_right_length(self):
        temp = self.tree.root
        len = 1
        while temp:
            temp = temp.left
            len += 1
        return len
    
    def get_fontsize(self):
        count = self.tree.size
        if count < 10:
            return 30
        if count < 20:
            return 20
        return 16

新建一个脚本文件test01.py

from RBTree import RBTree 
from Draw_RBTree import Draw_RBTree

t = RBTree()
t.put(10)
t.put(66)
t.put(77)
t.put(1)
t.put(2)
t.put(3)
t.put(4)
t.put(5)
t.put(6)
t.put(7)
t.put(8)
t.put(9)
t.put(88)
t.put(99)
t.put(100)
t.put(101)
d = Draw_RBTree(t)
d.show_rb_tree('红黑树示意图')
for i in t:
    print(i)

最终结果:

红黑树测试一

注意 如果插入的顺序不同，生成的红黑树结构不一定完全相同，但是高度保持的比较稳健

t = RBTree()
t.put(10)
t.put(77)
t.put(1)
t.put(2)
t.put(99)
t.put(66)
t.put(100)
t.put(3)
t.put(8)
t.put(88)
t.put(101)
t.put(4)
t.put(5)
t.put(9)
t.put(6)
t.put(7)
d = Draw_RBTree(t)
d.show_rb_tree('红黑树示意图')

最终结果:

红黑树测试二

红黑树的删除

红黑树的删除就十分复杂了，我们一步一步来，先回到普通二叉查找树的删除，二叉查找树的删除分为以下三种情况

  • 1.删除叶子节点，直接删除
  • 2.删除叶子节点有一个子节点，由子节点代替
  • 3.删除叶子节点有两个子节点，那么此时需要获取对应的后继(或者前驱)节点来替代，然后把后继(前驱)节点删掉（删掉他们时会回到1、2两种情况)

先来实现找到前驱和后继节点

    # 寻找前驱节点,前驱节点是恰好比该节点小的节点，一定在该节点左节点的最右边
    def find_pred(self, node):
        # 如果有左or右子节点
        if node.hasright() or node.hasleft():
            temp = node.left
            while temp.right:
                temp = temp.right
            return temp
        # 如果要查找叶子节点的前驱节点(这种情况不会发生在删除操作中，只是完善功能罢了)
        else:
            p = node.parent
            # 也有可能没有前驱
            while p and p.val > node.val:
                p = p.parent
            return p
     # 寻找后继节点,后继节点是恰好比该节点大的节点，一定在该节点右节点的最左边
    def find_subsequent(self, node):
        # 如果有左or右子节点
        if node.hasright() or node.hasleft():
            temp = node.right
            while temp.left:
                temp = temp.left
            return temp
        # 如果要查找叶子节点的后继节点(这种情况不会发生在删除操作中，只是完善功能罢了)
        else:
            p = node.parent
            # 也有可能没有后继
            while p and p.val < node.val:
                p = p.parent
            return p

当红黑树采用了普通二叉查找树的删除操作时，对应回2-3-4树，其实会发现删除的都是2-3-4树的叶子节点，也就是红黑树最多删除最底下两层叶子节点（因为就算是删除根节点，我们也会去找他的后继(前驱)来替代，删掉的还是后继(前驱)),而对应2-3-4树的叶子节点被删除有这3种情况：

  • 1.删除的是3-节点或4-节点中的元素，直接删除
  • 2.删除的是2-节点，如果兄弟节点是3-节点或4-节点，父节点到删除节点位置，兄弟节点上升一个
  • 3.删除节点是2-节点，如果兄弟节点也是2-节点，那就不合法，必须重构2-3-4树

我们先用上面测试二的结果来对应一颗2-3-4树

红黑树测试二

与之相对应的2-3-4树

2-3-4树对应红黑树测试结果二

  • 1.如果删除的是5，6, 7这个4-节点的任何一个，直接删除即可
  • 2.如果删除的是88这个2-节点，那么99下降到88的位置，100上升到99的位置，101到100的位置，由3-节点变为2-节点
  • 3.如果接着第二步，继续删除99节点（因为99已经下沉到88节点位置，可以删除），那么他的兄弟节点都是2-节点，就必须重构2-3-4树（对于红黑树来说就是变色：因为2-3-4树的节点与红黑树的节点存在对应关系，变色可以改变节点类型

删除代码如下

    # 删除节点3种情况
    # 1.删除叶子节点，直接删除
    # 2.删除叶节点有一个子节点，由子节点来替代
    # 3.删除叶子节点有两个子节点，那么此时需要获取对应的后继节点来替代
    def _delete(self,node):
        # 有两个子节点
        if node.hasleft() and node.hasright():
            # 找到后继节点
            subsequent = self.find_subsequent(node)   
            node.val = subsequent.val
            # 那么要删除的就是后继节点了
            node = subsequent
        # 只有一个子节点的情况,就把子节点与当前节点替换，然后删掉当前节点
        if node.hasleft() or node.hasright():
            if node.hasleft():
                temp = node.left
                temp.parent = node.parent
                if node.isroot():
                    self.root = temp
                elif node.isleft():
                    node.parent.left = temp
                else:
                    node.parent.right = temp
            else:
                temp = node.right
                temp.parent = node.parent
                if node.isroot():
                    self.root = temp
                elif node.isleft():
                    node.parent.left = temp
                else:
                    node.parent.right = temp
            # 将node节点与红黑树脱离联系等待垃圾回收
            node.left = None
            node.right = None
            node.parent = None
            # 最后调整
            if node.color == 'black':
                self.fixAfterRemove(temp)
        # 如果没有子节点
        else:
            # 先调整
            if node.color == 'black':
                self.fixAfterRemove(node)
            if node.isroot():
                self.root = None
            elif node.isleft():
                node.parent.left = None
                node.parent = None
            else:
                node.parent.right = None
                node.parent = None
    
    #  2-3-4树叶子节点的删除有三种情况：
    #         1.删除的是3节点或4节点中的元素，直接删除 
    #         2.删除的是2节点，如果兄弟节点是3-节点或者4-节点，父节点到删除节点位置，兄弟节点上升一个
    #         3.删除的是2节点，如果兄弟节点也是2-节点，那就不合法，必须重构2-3-4树
    def fixAfterRemove(self, node):
        # 情况2和3
        while not node.isroot() and node.getcolor() == 'black':
            if node.isleft():
                # 查找兄弟节点
                temp = node.parent.right
                # 如果兄弟节点的颜色是红色，说明不是真正的兄弟节点，先将(假的)兄弟节点
                # 变为黑色，再将该节点的父节点变为红色，对父节点进行左旋
                if temp.getcolor() == 'red':
                    temp.setcolor('black')
                    node.parent.setcolor('red')
                    self.leftRotate(node.parent)
                    # 这样就能得到真正的兄弟节点
                    temp = node.parent.right
                # 如果兄弟节点的子节点都是黑色（都是2-节点）情况3
                # 或者是兄弟节点就是2-节点
                if (not temp.hasleft() or temp.left.getcolor() == 'black') and (not temp.hasright() or temp.right.getcolor() == 'black'):
                    # 需要递归地调整整颗树的结构
                    temp.setcolor('red')
                    node = node.parent
                # 情况2
                else:
                    # 如果兄弟节点存在左子节点,就对兄弟节点变为红色，其子节点变为黑色
                    # 对兄弟节点做右旋操作，让其子节点上升，自己下降，变为根右右型
                    if not temp.hasright() or temp.right.getcolor()=='black':
                        temp.setcolor('red')
                        temp.left.setcolor('black')
                        self.rightRotate(temp)
                        # 兄弟节点更新
                        temp = node.parent.right
                    # 现在兄弟节点存在右子节点
                    # 就让兄弟节点去成为父节点，兄弟节点的子节点代替其位置
                    # 父节点下沉为原本node节点所在位置
                    temp.setcolor(node.parent.getcolor())
                    node.parent.setcolor('black')
                    temp.right.setcolor('black')
                    self.leftRotate(node.parent)
                    node = self.root
            else:
                 # 查找兄弟节点
                temp = node.parent.left
                # 如果兄弟节点的颜色是红色，说明不是真正的兄弟节点，先将(假的)兄弟节点
                # 变为黑色，再将该节点的父节点变为红色，对父节点进行右旋
                if temp.getcolor() == 'red':
                    temp.setcolor('black')
                    node.parent.setcolor('red')
                    self.rightRotate(node.parent)
                    # 这样就能得到真正的兄弟节点
                    temp = node.parent.left
                # 如果兄弟节点的子节点都是黑色（都是2-节点）情况3
                if (not temp.hasleft() or temp.left.getcolor() == 'black') and (not temp.hasright() or temp.right.getcolor() == 'black'):
                    # 需要递归地调整整颗树的结构
                    temp.setcolor('red')
                    node = node.parent
                # 情况2
                else:
                    # 如果兄弟节点存在右子节点,就对兄弟节点变为红色，其子节点变为黑色
                    # 对兄弟节点做左旋操作，让其子节点上升，自己下降，变为根左左型
                    if not temp.hasleft() or temp.left.getcolor()=='black':
                        temp.setcolor('red')
                        temp.right.setcolor('black')
                        self.leftRotate(temp)
                        # 兄弟节点更新
                        temp = node.parent.left
                    # 现在兄弟节点存在右子节点
                    # 就让兄弟节点去成为父节点，兄弟节点的子节点代替其位置
                    # 父节点下沉为原本node节点所在位置
                    temp.setcolor(node.parent.getcolor())
                    node.parent.setcolor('black')
                    temp.left.setcolor('black')
                    self.rightRotate(node.parent)
                    node = self.root
        # 情况1: 替代的节点是红色，直接设置为黑色即可
        node.setcolor('black')

测试红黑树删除

依然沿用刚才的插入代码，先插入再删除

根据刚才的分析，验证一下代码是否如我们所愿，

  • 1.删除5节点，整体没变化，只是5节点消失

红黑树删除5

  • 1.1.因为我们采用的是删除节点用后继节点替代，删除4理应与删除5的效果一致，即只是4被5代替，5消失

红黑树删除4

  • 2.删除88节点，99下降变黑，100上升变红，101上升变黑

红黑树删除88

  • 2.1根据前面的思路，那么删除77与删除88应该是一样的，只是88替代了77的位置

红黑树删除77

  • 3.在删除88后继续删除99，整个红黑树的结构就要改变

红黑树删除88和99

从图中看出，其实变化不大，是不是我们分析错了呢，不一定是，因为结构怎么变，不能只看局部，这个结构的变化在向上传导的过程中满足了2-3-4树的构成，就不会继续改变，我们把删除了88、99的2-3-4树画一下

2-3-4树对应红黑树删除88和99

  • 3.1在删除88、99后继续删除66、77

红黑树删除88、99和66、77

而此时变化就很大了，如果我们假设2-3-4树结构不变，再画一下2-3-4树，发现这个2-3-4树是不合法的，在100节点下，缺少了一个子节点

2-3-4树对应红黑树删除88、99和66、77

而调整结构后的2-3-4树，应该是这样

2-3-4树对应红黑树删除88、99和66、77

测试代码

from RBTree import RBTree 
from Draw_RBTree import Draw_RBTree
t = RBTree()
t.put(10)
t.put(77)
t.put(1)
t.put(2)
t.put(99)
t.put(66)
t.put(100)
t.put(3)
t.put(8)
t.put(88)
t.put(101)
t.put(4)
t.put(5)
t.put(9)
t.put(6)
t.put(7)
# t.delete(5)
# t.delete(4)
# t.delete(88)
# t.delete(77)
t.delete(88)
t.delete(99)
t.delete(66)
t.delete(77)
d = Draw_RBTree(t)
d.show_rb_tree('红黑树删除88、99和66、77')

好啦，这就是红黑树的所有代码啦，至于删除时的情况三：是怎样将变化向爷爷节点传递的，需要仔细阅读代码，细心体会，天机不可泄露喔!!

完整代码，请到我的Github上获取，文件名为RBTree.py和Draw_RBTree.py

PD我是你的真爱粉
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
红黑树详解
nullcanon的博客
04-01 969
红黑树 红黑树是一棵二叉搜索树，它在每一个节点上增加了一个表示颜色的指针，红色或者黑色。 一棵红黑树是满足下面性质的二叉搜索树： 每个节点非红即黑 根结点是黑色的 每个叶节点(这里的叶节点是指NULL节点)是黑色的 如果一个节点是红的，那么两个子节点都是黑的 对于任一节点，从该节点到所有后代叶节点的路径上，黑色节点的数目相等 由于这些性质的约定，红黑树没...
红黑树简介
u014520797的专栏
03-04 219
引用：https://www.cnblogs.com/yyxt/p/4983967.html http://www.360doc.com/content/18/0904/19/25944647_783893127.shtml http://www.sohu.com/a/201923614_466939 https://www.cnblogs.com/slgkaifa/p/6780299.ht...
算法导论——（4）有序统计树（OrderStatisticTree，以红黑树为基本数据结构）
a591193965的博客
08-20 2429
有序统计树是以红黑树为基本数据结构，增加了一个字段size,size表示以当前结点为树根的树上的节点数目，很明显有这样的关系根节点的size等于左孩子的size加上右孩子的size+1。 另外，如果之前有了解过有序统计量的相关知识，其中有一个操作便是查找排好顺序的列表中的某个特定索引的元素。那么有序统计树也是在红黑树的基础上加了这个操作。下面来分析OST（有序统计树）在红黑树上变化的部分。 1.
红黑树介绍
热门推荐
mz474920631的博客
05-28 4万+
红黑树一、红黑树的概念红黑树的性质红黑树节点的定义红黑树结构二、使用步骤1.引入库2.读入数据总结 一、红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数
merger红黑树
qq_45256489的博客
07-23 110
package cn.lyf; public class rbt { Node root; class State { boolean bal; Node cur; public State(Node cur, boolean bal) { this.bal = bal; this.cur = cur; } } public void ins(int k)
04_红黑树_基本概念_添加_删除——终极详细版
weixin_45442495的博客
03-25 413
红黑树具体操作 添加操作、代码 删除
读书笔记：《算法导论》版本的红黑树实现.zip
07-25
读书笔记：《算法导论》版本的红黑树实现
读书笔记：根据算法导论和sky王的资料详细的对红黑树的算法的实现.zip
最新发布
07-26
读书笔记：根据算法导论和sky王的资料详细的对红黑树的算法的实现
链表和红黑树测试代码
10-09
linux内核双向环形链表和红黑树，源码学习，摘录部分代码编译成库，进行测试
数据结构与算法学习笔记（十），左偏红黑树
06-01
笔记而已，不要太较真，有错误请立即指出。 类： 节点类 红黑树类 函数： 左旋，右旋，反转颜色，添加，查找。
算法笔记.胡凡(详细书签)
04-22
8. **数据结构高级话题**：可能涉及树结构（如二叉树、平衡树AVL和红黑树）、堆（最大堆和最小堆）、 Trie 字典树等。 9. **算法设计与分析技巧**：教授如何设计新的算法，如何从已有的算法中汲取灵感，以及如何...
数据结构之红黑树——红黑树是2-3-4B树的一种实现
xiaoyaocbc的博客
10-25 862
红黑规则是很好理解的，死记硬背也能背下来，但是如果放到复杂的实际应用中可能我们就懵了。今天在看一篇文章后，我才学到了从红黑树的概念模型2-3-4树出发，理解了红黑树五大定义背后的逻辑 ，深刻认识到红黑节点颜色背后的意义，对于插入删除引发的动态变化有一定的认识，而不再是去硬性的记忆某个场景下的调平操作。
红黑树并没有我们想象的那么难(上)
weixin_30305735的博客
09-26 275
<红黑树并没有我们想象的那么难> 上、下两篇已经完成, 希望能帮助到大家. 红黑树并没有我们想象的那么难(上) 红黑树并没有我们想象的那么难(下) 红黑树并没有想象的那么难, 初学者觉得晦涩难读可能是因为情况太多. 红黑树的情况可以通过归结, 通过合并来得到更少的情况, 如此可以加深对红黑树的理解. 网络上的大部分红黑树的讲解因为没有「合并」. 红黑树的五个性质: ...
漫画：什么是红黑树？（整合版）
程序员小灰的博客
05-25 3万+
前段时间，小灰发布了红黑树相关的文章，分成上下篇来讲解。这一次，小灰把两篇文章做了整合，并且修正了红黑树删除部分的图片错误，感谢大家的指正。————— 第二天 ———————————...
(笔记整合)红黑树
Da.的博客
04-08 241
一、什么是“平衡二叉查找树”？ 平衡二叉树的严格定义是这样的：二叉树中任意一个节点的左右子树的高度相差不能大于1。从这个定义来看，我们讲的完全二叉树、满二叉树其实都是平衡二叉树，但是非完全二叉树也有可能是平衡二叉树。 但是很多平衡二叉查找树其实并没有严格符合上面的定义,我们学习数据结构和算法是为了应用到实际的开发中的，所以，没必去死抠定义。对于平衡二叉查找树这个概念，我们要从这个数据结构的由来，...
红黑树详细讲解（多文整合）
IceTeaSet的专栏
08-27 927
红黑树简介 基本操作 1 基本旋转操作 2 求节点的后继节点 插入 删除 代码
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 960
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
红黑树算法详解：性质、旋转、插入、删除操作
红黑树算法详解 红黑树（Red-Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树的特点是利用树中节点“红黑着色”的限制，降低平衡性的条件，达到局部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

PD我是你的真爱粉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值