左倾红黑树Go语言实现

最新推荐文章于 2022-10-22 14:19:24 发布
最新推荐文章于 2022-10-22 14:19:24 发布
阅读量177 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DreamPoem/article/details/113601612
版权

文章目录

左倾红黑树的定义

含有红黑链接（边）并满足下列条件的二叉查找树：

  • 红链接均为左链接
  • 没有任何一个结点同时和两条红链接相连；
  • 该树是完美黑色平衡的，即任意空链接到根结点的路径上的黑链接数量相同。

红链接将两个2-结点（普通二叉树结点）链接起来构成一个3-结点（含有两个键，3个链接）；黑链接则是2-3树中的普通链接。

满足这样定义的红黑树和相应的2-3树是一一对应的。 将红链接画平时，一颗红黑树就是一颗2-3树

在这里插入图片描述

红黑树性质

（1）每个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
（4）如果一个节点是红色的，则它的子节点必须是黑色的。
（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树（AVL），性质5保证红黑树中最大长度不超过最小长度2倍 。（最小长度全部由黑结点组成，最大长度由红黑结点交替构成）。

将左倾红黑树转化为2-3树就能明白上述性质。

Node数据结构

将链接的颜色保存在表示结点的Node数据类型的布尔变量color中；如果指向它的链接是红色的，那么该变量为true，黑色则为false。

当我们提到一个结点的颜色时，指的是指向该结点的链接的颜色。

    type Color bool
    
    type Key string
    type Value int
    
    const (
    	RED   = true
    	BLACK = false
    )
    
    type RBT struct {
    	root *Node
    }
    
    // 红链接将两个2-结点链接起来构成一个3-结点
    // 黑链接则是2-3树中的普通链接。
    type Node struct {
    	key         Key
    	val         Value
    	left, right *Node
    	color       Color // 由其父结点指向它的链接的颜色，true-红链接，false-黑链接
    	n           int   // 这棵子树中的结点总书
    }
    
    func NewNode(key Key, val Value, n int, color Color) *Node {
    	return &Node{
    		key:   key,
    		val:   val,
    		color: color,
    		n:     n,
    	}
    }

旋转


在这里插入图片描述

插入

新插入的结点，总是用红链接将其与它的父结点相连；

插入新结点后：

  1. 使得父结点有两条红链接，那么直接将其转为两个黑链接即可；（0次旋转）
  2. 如果产生一条红色的右链接，就对父结点执行左旋操作；（1次旋转）
  3. 如果产生连续的两条红右链接，就对上层的红链接执行一次右旋转，转为情况1；（1次旋转）
  4. 如果产生连续的两条连续的红链接，一条红色左链接，一条红色右链接；只需将下层的红色右链接执行一次左旋转，转为情况3；（2次旋转）
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

颜色转换

在这里插入图片描述

删除

参考：

实现

    package red_black
    
    type Color bool
    
    type Key int
    type Value int
    
    const (
    	RED   = true
    	BLACK = false
    )
    
    type RBT struct {
    	root *Node
    }
    
    // 红链接将两个2-结点链接起来构成一个3-结点
    // 黑链接则是2-3树中的普通链接。
    type Node struct {
    	key         Key
    	val         Value
    	left, right *Node
    	color       Color // 由其父结点指向它的链接的颜色，true-红链接，false-黑链接
    	size        int
    }
    
    func NewNode(key Key, val Value, color Color, size int) *Node {
    	return &Node{
    		key:   key,
    		val:   val,
    		left:  nil,
    		right: nil,
    		color: color,
    		size:  size,
    	}
    }
    
    func isRed(node *Node) bool {
    	if node == nil {
    		return false
    	}
    	return node.color == RED
    }
    
    func (this *RBT) isEmpty() bool {
    	return this.root == nil
    }
    
    func size(h *Node) int {
    	if h == nil {
    		return 0
    	}
    	return h.size
    }
    
    func (this *RBT) Size() int {
    	return size(this.root)
    }
    
    func findMin(h *Node) *Node {
    
    	for h.left != nil {
    		h = h.left
    	}
    	return h
    }
    
    // 左旋
    func rotateLeft(h *Node) *Node {
    	x := h.left
    	h.left = x.right
    	x.right = h
    	x.color = h.color
    	h.color = RED
    	x.size = h.size
    	h.size = 1 + size(h.left) + size(h.right)
    	return x
    }
    
    // 右旋
    func rotateRight(h *Node) *Node {
    	x := h.right
    	h.right = x.left
    	x.left = h
    	x.color = h.color
    	h.color = RED
    	x.size = h.size
    	h.size = 1 + size(h.left) + size(h.right)
    	return x
    }
    
    func flipsColor(h *Node) {
    	h.color = !h.color
    	h.left.color = !h.left.color
    	h.right.color = !h.right.color
    }
    
    func fixUp(h *Node) *Node {
    
    	// 存在红色右链接，需要右转
    	if !isRed(h.left) && isRed(h.right) {
    		h = rotateRight(h)
    	}
    	// 存在两天连续的红色左链接，需要左转
    	if isRed(h.left) && isRed(h.left.left) {
    		h = rotateLeft(h)
    	}
    	if isRed(h.left) && isRed(h.right) {
    		flipsColor(h)
    	}
    	h.size = 1 + size(h.left) + size(h.right)
    	return h
    }
    
    func (this *RBT) Put(key Key, val Value) {
    	this.root = put(this.root, key, val)
    	this.root.color = BLACK
    }
    
    func put(h *Node, key Key, val Value) *Node {
    	if h == nil {
    		return NewNode(key, val, RED, 1)
    	}
    
    	if key < h.key {
    		h.left = put(h.left, key, val)
    	} else if key > h.key {
    		h.right = put(h.right, key, val)
    	} else {
    		h.key = key
    		h.val = val
    	}
    	return fixUp(h)
    }
    
    // 让左孩子结点变红，即3-结点
    func moveRedLeft(h *Node) *Node {
    	flipsColor(h)
    	// 如果h的右子结点是一个2-结点，只用反转颜色即可
    	// 若h的右子结点是个3-结点，需要从h的右子结点借一个给h的左子结点
    	if isRed(h.right.left) {
    		// 左旋右子节点
    		h.right = rotateLeft(h.right)
    		// 右旋h
    		h = rotateRight(h)
    		// 颜色翻转
    		flipsColor(h)
    	}
    	return h
    }
    
    // 让右子结点变成红结点，即3-结点
    func moveRedRight(h *Node) *Node {
    
    	flipsColor(h)
    	// h.right是一个2-结点
    	// h.left是h.right的兄弟结点，且h.left是一个3-结点，需要借给h.left一个键
    	// 这里只进行一次左旋即可
    	if isRed(h.left.left) {
    		h = rotateLeft(h)
    		flipsColor(h)
    	}
    	return h
    }
    
    // delete 就是在查找路径上进行和deleteMin、deleteMax相同的变换
    // 要求保证在查找过程中任意当前结点不是2-结点。
    // 如果被删除的值在树的底部，我们可以直接删除它。
    // 如果不在，我们需要和二叉查找树中的删除一样：
    // 用其右子树的最小的值代替该节点的值，并删除那个节点(右子树的最小的值)。
    // 然后问题已经转化为在一棵根节点的子树中删除最小值，可以使用上面写的删除最小值的方法。
    func delete(h *Node, key Key) *Node {
    
    	if key < h.key {
    
    		// 向左子树搜索，保证左节点不是2-结点
    		if !isRed(h.left) && !isRed(h.left.left) {
    			h = moveRedLeft(h)
    		}
    		h.left = delete(h.left, key)
    	} else {
    
    		// h.left为红便左旋，使得h.right变红
    		if isRed(h.left) {
    			h = rotateLeft(h)
    		}
    
    		// 找到目标结点
    		if key == h.key && h.right == nil {
    			// 左子数不为红，且右子树为空，那么左子数只能是空；不然黑节点的高度不平衡
    			return nil
    		}
    
    		// 无论如何都要删除右子树中的结点
    		// 	如果要删的是h，与右子树的min对调后删除右子树的min
    		// 	否则目标节点在右子树中
    		// 所以需要让右子结点变红
    		if !isRed(h.right) && !isRed(h.right.right) {
    			h = moveRedRight(h)
    		}
    
    		// 找到目标节点，将其替换为右子树的最小值
    		// 并删除右子树的最小值
    		if key == h.key {
    			t := findMin(h.right)
    			h.key = t.key
    			h.val = t.val
    			h.right = delete(h.right, t.key) // 等同于 deleteMin(h.right)
    		} else {
    			h.right = delete(h.right, key)
    		}
    	}
    	return fixUp(h)
    }
    
    func (this *RBT) Delete(key Key) {
    	if !this.Contain(key) {
    		return
    	}
    	this.root = delete(this.root, key)
    	if this.root != nil {
    		this.root.color = BLACK
    	}
    }

Keys

    func keys(h *Node, res *[]Value) {
    	if h == nil {
    		return
    	}
    	keys(h.left, res)
    	*res = append(*res, h.val)
    	keys(h.right, res)
    	return
    }
    
    func (this *RBT) Keys() []Value {
    	ans := make([]Value, 0)
    	keys(this.root, &ans)
    	return ans
    }

Contains

    func contrains(h *Node, key Key) *Node {
    	if h == nil {
    		return nil
    	}
    
    	if key == h.key {
    		return h
    	} else if key < h.key {
    		return contrains(h.left, key)
    	} else {
    		return contrains(h.right, key)
    	}
    }
    
    func (this *RBT) Contains(key Key) bool {
    	return contrains(this.root, key) != nil
    }

DeleteMin、DeleteMax

    func deleteMax(h *Node) *Node {
    	// h.left是一个红节点，不是h.right的兄弟结点
    	// 需要向左旋转，使得h.left变红，方便从右子树里删除
    	if isRed(h.left) {
    		h = rotateLeft(h)
    	}
    	if h.right == nil {
    		return nil
    	} else if !isRed(h.right) && !isRed(h.right.left) {
    		// h.right 是一个 2-结点
    		// 两种情况：
    		// 1. h.left也是一个2-结点，秩序反转颜色即可
    		// 2. h.left是一个3-结点，需要从
    		h = moveRedRight(h)
    	}
    	h.right = deleteMax(h)
    	return fixUp(h)
    }
    
    func (this *RBT) DeleteMax() {
    	this.root = deleteMax(this.root)
    	if this.root != nil {
    		this.root.color = BLACK
    	}
    }
    
    func deleteMin(h *Node) *Node {
    	if h.left == nil {
    		return nil
    	}
    	// 左子结点是一个2-结点
    	if !isRed(h.left) && !isRed(h.left.left) {
    		// 两种情况：
    		// 1. 右子结点也是一个2-结点，直接颜色翻转即可
    		// 2. 右子结点是一个3-结点，从右子结点借一个给左子结点
    		h = moveRedLeft(h)
    	}
    	h.left = deleteMin(h.left)
    	return fixUp(h)
    }
    
    func (this *RBT) DeleteMin() {
    	this.root = deleteMin(this.root)
    	if this.root != nil {
    		this.root.color = BLACK
    	}
    	return
    }

Rank、Get

Rank(key Key)返回key的排名，从0开始计数

Get(index int)返回排名为index的key，index从0开始计数

    // 返回排名为rank的结点
    // rank从0开始
    func get(h *Node, rank int) *Node {
       if h == nil || rank == size(h.left) {
          return h
       }
    
       lsize := size(h.left)
       if rank > lsize {
          return get(h.right, rank-lsize-1)
       } else {
          return get(h.left, rank)
       }
    }
    
    func (this *RBT) Get(rank int) *Node {
       if rank < 0 || rank >= this.Size() {
          return nil
       }
       return get(this.root, rank)
    }
    
    // 返回key的排名，从0开始计数
    func rank(h *Node, key Key) int {
       // 返回以h为根节点的子树中小于h.key的键的数量
       if h == nil {
          return 0
       }
       if key == h.key {
          return size(h.left)
       } else if key < h.key {
          return rank(h.left, key)
    
       } else {
          return 1 + size(h.left) + rank(h.right, key)
       }
    }
    
    // 红黑树中不存在key返回-1
    func (this *RBT) Rank(key Key) int {
       if !this.Contain(key) {
          return -1
       }
       return rank(this.root, key)
    }

Ceil

    func ceil(h *node, key int) *node {
    	if h == nil {
    		return nil
    	}
    	
        // h 可能是一个合格的结点，向左尝试找 key <= x < h.key
    	if h.key >= key {
    		tmp := ceil(h.left, key)
    		if tmp != nil {
    			return tmp
    		}
    		return h
    	} else {
    		return ceil(h.right, key)
    	}
    
    }
    
    func (this *RBT) Ceil(key int) (bool, int) {
    	n := ceil(this.root, key)
    	if n == nil {
    		return false, -1
    	}
    	return true, n.val
    }

Floor

    func floor(h *node, key int) *node {
    	if h == nil {
    		return nil
    	}
        // h 可能是一个合格的结点，也可以向右尝试找 h.key < x <= h.key
    	if h.key <= key {
    		tmp := floor(h.right, key)
    		if tmp != nil {
    			return tmp
    		}
    		return h
    	} else {
    		return floor(h.left, key)
    	}
    
    }
    
    func (this *RBT) Floor(key int) (bool, int) {
    	n := ceil(this.root, key)
    	if n == nil {
    		return false, -1
    	}
    	return true, n.val
    }

例题

  • leetcode 220. 存在重复元素 III：红黑树的添加与删除，实现Ceil(key)找到第一个大于key的数，Floor(key)找到最后一个小于key的数。
  • leetcode 436 寻找右区间：红黑树的添加、Ceil(key)实现；将区间的左端点作为key，下标作为val构建红黑树；多于每一个区间[start,edn]调用Ceil(end)找到第一个大于等于end的左区间端点，并返回其下标即可。
陆垚知马俐·
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GO数据结构——红黑树（一.基础操作）
qq_53057924的博客
09-23 1005
1.简介 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。在开发当中，红黑树的综合效率最高，复杂度也最高。 红黑树的特性: （1）每个节点或者是黑色，或者是红色。（红色代表true，黑色代表false） （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。[注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点] （4）如果一个节点是红色的，则它的子节点必须是黑色的
Golang实现红黑树
只数月亮不数星星的博客
05-02 4221
红黑树基于golang的实现，主要介绍如何实现红黑树的调整。在此中加入了自己在实现过程中的些许感受和在处理逻辑时需要注意的细节。
红黑树详解及实现(golang)
weixin_46041797的博客
09-29 980
参考 插入过程参考《STL源码剖析》 删除过程参考《算法导论》以及博客：红黑树的删除操作 源码实现参考nginx中红黑树的实现和《STL源码剖析》 红黑树的定义 学习、理解红黑树时，必须时紧紧刻围绕着红黑树的定义 以下是《STL源码剖析》中给出的定义： 根节点是黑色 每个节点非红即黑 如果一个节点为红色，它的子节点必为黑色 任何一个节点至NULL（树尾端）的任何路径，所含黑节点数必须相同 红黑树的节点的定义 type RbTreeColor bool type RbTreeKeyType int t
左倾红黑树的go语言实现
学者的博客
10-22 422
红黑树经常能在计算机底层代码中见到，比如C++的map，multimap, set, multisetLinux中rdtree用以管理内存和进程Java中的HashMap左倾红黑树是对红黑树的一种改进，在保持红黑树的优良性能情况下使得实现更加的容易。本文解释其原理并使用GO语言对它进行了实现。无论左倾红黑树还是红黑树都是对它们的原型2-3-4树的一种实现。2-3-4树有一个非常好的性质：树上所有从根结点到叶子结点的路径都是等长的。这意味着查找、插入、删除这三种操作时间复杂度都是O(l。
（23）Go实现红黑树-算法解析
哥斯拉啊啊啊哦的博客
09-04 300
红黑树，叫red black tree/2b tree，了解红黑树之前，先了解下2-3树，2-3树容易理解 且和红黑树有某种等价性，了解2-3树有助于了解红黑树 // 如以上图过程： // 1）每次插入新节点时，都是先找到要插入的最后节点，与最后节点相融合； 2）融合后如果是3节点，则后续不变； 3）融合后如果是4节点，则分裂一棵子树，并将其父节点向上一级融合，直到根节点为止 2-3树和...
red-black-tree:C - 左倾红黑树实现
06-02
左倾红黑树是一种自平衡二叉查找树（AVL树的一种变种），它在保持红黑树特性的同时，通过特定的旋转策略优化了插入和删除操作。红黑树的关键特性是： 1. 每个节点不是红色就是黑色。 2. 根节点是黑色。 3. 所有叶子...
红黑树实现源码
07-22
在提供的“红黑树.txt”文件中，可能包含了红黑树的具体源代码实现，可以详细阅读理解其工作原理。 总结来说，红黑树是一种高效且实用的数据结构，它的核心在于通过颜色属性和相应的调整策略来保持树的平衡，从而在...
红黑树源码java-leftrb:Leftrb是Python中2-3个平衡二叉搜索树的左倾红黑(LLRB)实现。RobertSedgewick
06-06
个平衡二叉搜索树的左倾红黑 (LLRB) 实现。 这是 Robert Sedgewick 在 [他的论文](() 和由 Robert Sedgewick 和 Kevin Wayne 撰写的书中介绍的 Java 代码的直接移植。经他们许可，被许可为 LGPL v3，并移植到Python...
Java实现的红黑树
12-25
使用这些源码，可以学习和理解红黑树的具体实现细节，比如如何处理插入和删除时的平衡问题，以及如何在Java中编写高效的二分查找树代码。 6. **应用场景** - 数据库索引：红黑树常用于数据库的B+树索引实现。 - ...
左倾树数据结构
06-08
左倾树是一种高级数据结构，主要用于实现易融合优先级队列，能够减少融合操作、插入、删除最小最大元的时间到对数函数时间，同时查找最小（最大）元的时间可以是 O(1)。 左倾树可以分为两种：高度左倾树（HBLT）和...
红黑树原理详解及golang实现
weixin_30512089的博客
06-02 398
目录 红黑树原理详解及golang实现 二叉查找树 性质 红黑树 性质 operation 红黑树的插入 golang实现 类型定义 leftRotate ...
Golang实现的红黑树
闷骚的Gopher
04-13 4000
红黑树是一种基于
golang 手撕红黑树
l1002544188的博客
03-21 1262
GOLANG 手撕红黑树 前言 GOLANG表中包中自带的数据结构比较少，目前找到的红黑树都是开源实现，索性自己手撕一颗来练练手。以下主要讲解代码实现。 github地址:https://github.com/Julius-Li/daily/tree/master/rbtree 红黑树简单介绍 红黑树是一种不严格平衡二叉树，通过**保持其性质**就能保持整个树的平衡。红黑...
Go语言实现二叉树（BinaryTree）
xing的博客
10-29 808
go语言实现二叉树（BinaryTree） &amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;使用go语言实现了二叉树的一些基本功能，存储节点数据的类型为int。（有什么建议或者不懂的地方可以留言） 实现代
左倾红黑树（Left-Leaning Red-Black Trees：LLRBT）解析
寂寞风中一匹狼的博客
11-20 2015
左倾红黑树（LLRBT） 1.用普通的平衡二叉树（BST）表示2-3-4树 2.用内部的红边表示3-节点和4-节点（红边指入的节点为红节点） 所以我们可以用红黑树来表示2-3-4树。如下： 注意：对应关系不是唯一的（3个节点可以任意倾斜），对于一棵2-3-4树可能有多种不同的红黑树表示，这是因为对于3-node的表示，红色的边可以向左倾，也可以向右倾。 所以要考虑很多情况。但是我们只考虑左...
golang红黑树
m0_46210508的博客
07-31 575
golang和go泛型实现的红黑树！
红黑树实现-go
weixin_43644373的博客
12-02 134
红黑树实现-go原理插入删除代码 原理 红黑树是一种含有红黑结点并能自平衡的二叉查找树。它必须满足下面性质： 性质1：每个节点要么是黑色，要么是红色。 性质2：根节点是黑色。 性质3：每个叶子节点（NIL）是黑色。 性质4：每个红色结点的两个子结点一定都是黑色。 性质5：任意一结点到每个叶子结点的路径都包含数量相同的黑结点。 关于红黑树的插入和删除，楼主有时间会在后面补充，这里先贴上代码，代码里面...
左倾红黑树的特点和右倾红黑树的特点和区别
最新发布
05-24
左倾红黑树和右倾红黑树都是红黑树的变种，它们都是为了避免在插入元素时出现右旋操作而设计的。具体特点和区别如下： 左倾红黑树（Left-Leaning Red-Black Tree）： 1. 根节点是黑色的。 2. 所有红色节点都是向左...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值