golang红黑树

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

go语言红黑树

1.红黑树基础

1.结点不是红色就是黑色
2.根结点为黑色结点
3.所有叶子结点为黑色结点（叶子结点为nil结点）
4.红色结点的子结点必为黑色结点（叶子结点到根结点的路径上没有两个连续的红色结点）
5.从任一结点到叶子结点的路径上必有相同数目的黑色结点

2.泛型类型定义

type AVLType interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~float32 | ~float64 | ~string | ~uintptr
}
//红黑结点
const (
	RED   = 0
	BLACK = 1
)

3.红黑树结构定义

//红黑树
type RedBlackTree[T AVLType] struct {
	lock        *sync.RWMutex    //互斥锁
	node        *redBlackNode[T] //红黑树根结点
	colorChange bool             //变色标志
}

//红黑树结点
type redBlackNode[T AVLType] struct {
	data           T
	lChild, rChild *redBlackNode[T]
	color          int
	parent         *redBlackNode[T]
}

4.红黑树结点的左旋与右旋

//结点左旋
func (r *redBlackNode[T]) leftRotate() *redBlackNode[T] {
	if r != nil {
		var R *redBlackNode[T]
		R = r.rChild
		r.rChild = R.lChild
		//左子树不为空需要更新父节点
		if R.lChild != nil {
			R.lChild.parent = r
		}
		if r.parent != nil && r == r.parent.lChild {
			r.parent.lChild = R
		} else if r.parent != nil && r == r.parent.rChild {
			r.parent.rChild = R
		}
		//空出r的父节点
		R.parent = r.parent
		R.lChild = r
		r.parent = R
		r = R
	}
	return r
}

//结点右旋
func (r *redBlackNode[T]) rightRotate() *redBlackNode[T] {
	if r != nil {
		var L *redBlackNode[T]
		L = r.lChild
		r.lChild = L.rChild
		//右子树不为空则更新父节点
		if L.rChild != nil {
			L.rChild.parent = r
		}
		if r.parent != nil && r == r.parent.lChild {
			r.parent.lChild = L
		} else if r.parent != nil && r == r.parent.rChild {
			r.parent.rChild = L
		}
		L.parent = r.parent
		L.rChild = r
		r.parent = L
		r = L
	}
	return r
}

5.红黑树的插入

//红黑树插入
func (r *RedBlackTree[T]) InsertRBT(e T) {
	r.lock.Lock()
	defer r.lock.Unlock()
	r.colorChange = false
	newNode := r.node.insertNode(e, &r.colorChange)
	if newNode.color == RED {
		newNode.parent = nil
		newNode.color = BLACK
	}
	r.node = newNode
}
//红黑树结点的插入
func (r *redBlackNode[T]) insertNode(e T, color *bool) *redBlackNode[T] {
	if r == nil {
		r = &redBlackNode[T]{
			data:   e,
			lChild: nil,
			rChild: nil,
			color:  RED,
			parent: nil,
		}
		*color = true //要进行变色
		return r
	} else {
		if r.data == e {
			//已有该值，直接返回
			*color = false
			return r
		} else if e < r.data {
			//插入左子树
			newNode := r.lChild.insertNode(e, color)
			if *color {
				if r.color == BLACK {
					//父节点黑色 无需操作
					if r == newNode {

						r.color = RED
						*color = true
						return r
					}
					newNode.parent = r //将新插入的节点接上
					r.lChild = newNode
					*color = false
					return r
				} else if (r.color == RED && r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.color == RED) || (r.color == RED && r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.color == RED) {
					//父节点和叔结点都是红色 父叔都变黑，祖父变红 然后递归
					r.lChild = newNode //将当前节点与新节点连接
					newNode.parent = r
					r.parent.lChild.color = BLACK
					r.parent.rChild.color = BLACK
					//r.parent.color = RED
					//newNode.parent = r
					*color = true
					return r.parent //返回祖父结点继续调整
				} else if r.color == RED && r == r.parent.lChild {
					//左左 右旋加变色
					r.lChild = newNode //将当前节点与新节点连接
					newNode.parent = r
					tmp := r.parent.rightRotate()
					tmp.color = BLACK
					tmp.rChild.color = RED
					*color = false
					return tmp
				} else {
					//右左 先右旋在左旋 变色
					r.lChild = newNode //将当前节点与新节点连接
					newNode.parent = r
					tmp1 := r.rightRotate()
					tmp2 := tmp1.parent.leftRotate()
					tmp2.color = BLACK
					tmp2.lChild.color = RED
					*color = false
					return tmp2
				}
			}
			if newNode.parent == nil {
				return newNode //旋转完成后如果变成了根结点则返回根结点
			}

		} else {
			//插入右子树
			newNode := r.rChild.insertNode(e, color)
			if *color {
				if r.color == BLACK {
					//父节点黑色 无需操作
					if r == newNode {
						r.color = RED
						*color = true
						return r
					}
					newNode.parent = r //将新插入的节点接上
					r.rChild = newNode
					*color = false
					return r
				} else if (r.color == RED && r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.color == RED) || (r.color == RED && r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.color == RED) {
					//父节点和叔结点都是红色 父叔都变黑，祖父变红 然后递归
					r.rChild = newNode //将当前节点与新节点连接
					newNode.parent = r
					r.parent.lChild.color = BLACK
					r.parent.rChild.color = BLACK
					//r.parent.color = RED
					//newNode.parent = r
					*color = true
					return r.parent //返回祖父结点继续调整
				} else if r.color == RED && r == r.parent.rChild {
					//右右 左旋加变色
					r.rChild = newNode //将当前节点与新节点连接
					newNode.parent = r
					tmp := r.parent.leftRotate()
					tmp.color = BLACK
					tmp.lChild.color = RED
					*color = false
					return tmp
				} else {
					//左右 先左旋在右旋 变色
					r.rChild = newNode //将当前节点与新节点连接
					newNode.parent = r
					tmp1 := r.leftRotate()
					tmp2 := tmp1.parent.rightRotate()
					tmp2.color = BLACK
					tmp2.rChild.color = RED
					*color = false
					return tmp2
				}
			}
			if newNode.parent == nil {
				//r.rChild = newNode
				return newNode //旋转完成后如果变成了根结点则返回根结点
			}

		}
	}
	return r
}

6.红黑树的删除

//红黑树结点删除
func (r *redBlackNode[T]) deleteRBTNode(e T, color *bool) *redBlackNode[T] {
	if r == nil {
		*color = false
		return r
	} else {
		if e == r.data {
			//找到待删除结点，开始做删除操作
			if r.color == RED && r.lChild == nil && r.rChild == nil {
				//删除红叶子节点,直接删除
				*color = false
				if r == r.parent.lChild {
					r.parent.lChild = nil
				} else {
					r.parent.rChild = nil
				}
				return nil
			} else if r.color == BLACK && r.lChild == nil && r.rChild == nil {
				//删除黑色叶子结点，分四种情况讨论
				if (r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.color == RED) || (r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.color == RED) {
					//兄弟结点为红色，转为兄弟结点为黑色
					if r == r.parent.lChild {
						//如果是左孩子 则左旋加变色
						tmp := r.parent.leftRotate()
						tmp.color = BLACK
						tmp.lChild.color = RED
					} else {
						//如果是右孩子 则右旋加变色
						tmp := r.parent.rightRotate()
						tmp.color = BLACK
						tmp.lChild.color = RED
					}
				}
				if r.parent.color == RED && ((r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.lChild == nil && r.parent.rChild.rChild == nil) || (r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.lChild == nil && r.parent.lChild.rChild == nil)) {
					//父节点为红色且侄子结点（兄弟结点的子节点）均为nil
					if r == r.parent.lChild { //删除结点
						r.parent.lChild = nil
						r.parent.rChild.color = RED //兄弟涂红
					} else {
						r.parent.rChild = nil
						r.parent.lChild.color = RED
					}
					*color = false
					r.parent.color = BLACK //父结点涂黑
					return r.parent
				} else if r.parent.color == BLACK && ((r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.lChild == nil && r.parent.rChild.rChild == nil) || (r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.lChild == nil && r.parent.lChild.rChild == nil)) {
					//父结点为黑色且侄子结点为nil
					if r == r.parent.lChild { //删除结点
						r.parent.lChild = nil
						r.parent.rChild.color = RED //兄弟涂红
					} else {
						r.parent.rChild = nil
						r.parent.lChild.color = RED
					}
					*color = true
					return r.parent
				} else {
					if r == r.parent.lChild {
						if r.parent.rChild.lChild != nil && r.parent.rChild.lChild.color == RED {
							//左侄子为红色
							r.parent.lChild = nil //删除结点
							tmp1 := r.parent.rChild.rightRotate()
							tmp1.color = r.parent.color
							r.parent.color = BLACK
							tmp2 := r.parent.leftRotate()
							*color = false
							return tmp2
						} else if r.parent.rChild.rChild != nil && r.parent.rChild.rChild.color == RED {
							//右侄子为红色
							r.parent.lChild = nil
							r.parent.rChild.color = r.parent.color
							r.parent.color = BLACK
							r.parent.rChild.rChild.color = BLACK
							tmp := r.parent.leftRotate() //左旋
							return tmp
						}
					} else if r == r.parent.rChild {
						if r.parent.lChild.rChild != nil && r.parent.lChild.rChild.color == RED {
							//右侄子为红色
							r.parent.rChild = nil //删除结点
							tmp1 := r.parent.lChild.leftRotate()
							tmp1.color = r.parent.color
							r.parent.color = BLACK
							tmp2 := r.parent.rightRotate()
							*color = false
							return tmp2
						} else if r.parent.lChild.lChild != nil && r.parent.lChild.lChild.color == RED {
							//左侄子为红色
							r.parent.rChild = nil
							r.parent.lChild.color = r.parent.color
							r.parent.color = BLACK
							r.parent.lChild.lChild.color = BLACK
							tmp := r.parent.rightRotate() //右旋
							return tmp
						}
					}
				}
			} else if r.lChild != nil && r.rChild == nil {
				//删除结点只有左孩子，将左孩子的值赋值给当前结点，并删除左孩子
				r.data = r.lChild.data
				r.lChild = nil
				*color = false
				return r
			} else if r.rChild != nil && r.lChild == nil {
				//删除结点只有右孩子，将右孩子的值赋值给当前结点，并删除右孩子
				r.data = r.rChild.data
				r.rChild = nil
				*color = false
				return r
			} else {
				//左右结点都存在，找到前驱结点，并将值替换，删除前驱结点
				L := r.lChild
				for L.rChild != nil {
					L = L.rChild
				}
				r.data = L.data
				L.deleteRBTNode(L.data, color)
				return r
			}
		} else if e < r.data {
			//去左子树找待删除结点
			newNode := r.lChild.deleteRBTNode(e, color)
			if *color {
				for !*color {
					if newNode.parent == nil {
						break
					}
					newNode, *color = deleteFixUp(newNode)
				}
			}
			if newNode != nil && newNode.parent == nil {
				return newNode
			}
		} else {
			//去右子树找待删除结点
			newNode := r.rChild.deleteRBTNode(e, color)
			if *color {
				for !*color {
					if newNode.parent == nil {
						break
					}
					newNode, *color = deleteFixUp(newNode)
				}
			}
			if newNode != nil && newNode.parent == nil {
				return newNode
			}
		}
	}
	return r
}

//删除调整
func deleteFixUp[T AVLType](r *redBlackNode[T]) (*redBlackNode[T], bool) {
	var color bool
	if (r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.color == RED) || (r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.color == RED) {
		//兄弟结点为红色，转为兄弟结点为黑色
		if r == r.parent.lChild {
			//如果是左孩子 则左旋加变色
			tmp := r.parent.leftRotate()
			tmp.color = BLACK
			tmp.lChild.color = RED
		} else {
			//如果是右孩子 则右旋加变色
			tmp := r.parent.rightRotate()
			tmp.color = BLACK
			tmp.lChild.color = RED
		}
	}
	if r.parent.color == RED && ((r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.lChild == nil && r.parent.rChild.rChild == nil) || (r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.lChild == nil && r.parent.lChild.rChild == nil)) {
		//父节点为红色且侄子结点（兄弟结点的子节点）均为nil
		if r == r.parent.lChild {
			//r.parent.lChild = nil
			r.parent.rChild.color = RED //兄弟涂红
		} else {
			//r.parent.rChild = nil
			r.parent.lChild.color = RED
		}
		color = false
		r.parent.color = BLACK //父结点涂黑
		return r.parent, color
	} else if r.parent.color == BLACK && ((r == r.parent.lChild && r.parent.rChild != nil && r.parent.rChild.lChild == nil && r.parent.rChild.rChild == nil) || (r == r.parent.rChild && r.parent.lChild != nil && r.parent.lChild.lChild == nil && r.parent.lChild.rChild == nil)) {
		//父结点为黑色且侄子结点为nil
		if r == r.parent.lChild {
			//r.parent.lChild = nil
			r.parent.rChild.color = RED //兄弟涂红
		} else {
			//r.parent.rChild = nil
			r.parent.lChild.color = RED
		}
		color = true
		return r.parent, color
	} else {
		if r == r.parent.lChild {
			if r.parent.rChild.lChild != nil && r.parent.rChild.lChild.color == RED {
				//左侄子为红色
				//r.parent.lChild = nil //删除结点
				tmp1 := r.parent.rChild.rightRotate()
				tmp1.color = r.parent.color
				r.parent.color = BLACK
				tmp2 := r.parent.leftRotate()
				color = false
				return tmp2, color
			} else if r.parent.rChild.rChild != nil && r.parent.rChild.rChild.color == RED {
				//右侄子为红色
				//r.parent.lChild = nil
				r.parent.rChild.color = r.parent.color
				r.parent.color = BLACK
				r.parent.rChild.rChild.color = BLACK
				tmp := r.parent.leftRotate() //左旋
				return tmp, color
			}
		} else if r == r.parent.rChild {
			if r.parent.lChild.rChild != nil && r.parent.lChild.rChild.color == RED {
				//右侄子为红色
				//r.parent.rChild = nil //删除结点
				tmp1 := r.parent.lChild.leftRotate()
				tmp1.color = r.parent.color
				r.parent.color = BLACK
				tmp2 := r.parent.rightRotate()
				color = false
				return tmp2, color
			} else if r.parent.lChild.lChild != nil && r.parent.lChild.lChild.color == RED {
				//左侄子为红色
				//r.parent.rChild = nil
				r.parent.lChild.color = r.parent.color
				r.parent.color = BLACK
				r.parent.lChild.lChild.color = BLACK
				tmp := r.parent.rightRotate() //右旋
				return tmp, color
			}
		}
	}
	return r, color
}

7.总结

菜鸟写法，测试虽然有用，但是效率比之前写过的平衡二叉树要低，以后有机会进行优化，欢迎各位大佬指正！

呐，好好学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang实现红黑树
只数月亮不数星星的博客
05-02 4220
红黑树基于golang的实现，主要介绍如何实现红黑树的调整。在此中加入了自己在实现过程中的些许感受和在处理逻辑时需要注意的细节。
Golang实现的红黑树
闷骚的Gopher
04-13 3996
红黑树是一种基于
红黑树详解及实现(golang)
weixin_46041797的博客
09-29 978
参考 插入过程参考《STL源码剖析》 删除过程参考《算法导论》以及博客：红黑树的删除操作 源码实现参考nginx中红黑树的实现和《STL源码剖析》 红黑树的定义 学习、理解红黑树时，必须时紧紧刻围绕着红黑树的定义 以下是《STL源码剖析》中给出的定义： 根节点是黑色 每个节点非红即黑 如果一个节点为红色，它的子节点必为黑色 任何一个节点至NULL（树尾端）的任何路径，所含黑节点数必须相同 红黑树的节点的定义 type RbTreeColor bool type RbTreeKeyType int t
Go最新【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树(1)，2024年最新赶紧学起来
最新发布
2401_84925044的博客
05-17 666
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取上面这颗红黑树，我们来将所有的红色节点上移到和他们的父节点同一高度上，就会形成如下结构这个结构很明显，就是一棵四阶B树（一个节点最多放三个数据），如果画成如下的样子大家应该就能看的更清晰了。由上面的等价变换我们就可以得
左倾红黑树的go语言实现
学者的博客
10-22 422
红黑树经常能在计算机底层代码中见到，比如C++的map，multimap, set, multisetLinux中rdtree用以管理内存和进程Java中的HashMap左倾红黑树是对红黑树的一种改进，在保持红黑树的优良性能情况下使得实现更加的容易。本文解释其原理并使用GO语言对它进行了实现。无论左倾红黑树还是红黑树都是对它们的原型2-3-4树的一种实现。2-3-4树有一个非常好的性质：树上所有从根结点到叶子结点的路径都是等长的。这意味着查找、插入、删除这三种操作时间复杂度都是O(l。
redblacktree:golang中的自平衡二叉搜索树
06-16
红黑树 。 用法 默认树期望键为int类型。 import ( "fmt" rbt "github.com/erriapo/redblacktree" ) func main () { t := rbt . NewTree () t . Put ( 7 , "payload7" ) t . Put ( 3 , "payload3" ) t . Put ( 1 , "payload1" ) fmt . Printf ( "size = %d \n " , t . Size ()) // size = 3 inorder := & rbt. InorderVisitor {}; t . Walk ( inorder ) fmt . Printf ( "tree = %s \n " , inorder ) // tree
（24）Go实现红黑树-实现和总结
哥斯拉啊啊啊哦的博客
09-04 378
继上一篇《（23）Go实现红黑树-算法解析》的后续： https://www.jianshu.com/p/8c41d1e52c32 红黑树的定义和实现 const ( Red = true Black = false ) type node struct { key int value int color bool left *node right *node } ty...
rbtree:Go的红黑树
05-04
请参阅分支以获取有争议的红黑树。 软件包rbtree实现了“算法简介”中引入的红黑树。 在当前语言规范下，有以下模式可以实现通用容器： 排序包使用的模式 type Interface interface { Compare ( another ...
红黑树应用 (1).mp4
09-05
内容包括：C/C++，Linux，Nginx，golang，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，ffmpeg，流媒体， 音视频，CDN，P2P，K8S，Docker，Golang,TCP/IP，协程，嵌入式，ARM，DPDK等等。。。
红黑树_算法详解_算法导论_20130505【for_wind】
05-10
（不需要资源分，不能修改上次的，只好重传了...红黑树算法(算法导论) 详解 【for_wind】，介绍了红黑树性质，详细分析了红黑树旋转，插入，删除等基本操作。其中算法的伪代码和算法导论中一致。 个人总结的，分享了。
TreeSet 红黑树结构算法
11-08
TreeSet 红黑树结构算法 TreeSet 红黑树结构算法是 Java 中的一种数据结构，它是基于红黑树数据结构的实现。红黑树是一种自平衡的排序二叉树，它可以保证快速检索指定节点。TreeSet 和 TreeMap 之间存在着紧密的...
golang_algorithm
03-17
在Go语言中，常见的数据结构包括数组、链表、队列、栈、哈希表、树（如二叉树、AVL树、红黑树）等。这些数据结构在不同的场景下有着各自的优势，例如，数组适合于随机访问，链表适合于动态插入和删除，哈希表则提供...
golang 红黑树map实现
sky_terra的专栏
06-11 786
//------------------------------------------------------------------------------ // rbtree.go // 红黑树 //------------------------------------------------------------------------------ package rbmap const ( RED bool = true BLACK bool = false ) type no.
RB-tree(zz)
xiaoxiongli的专栏
08-01 3093
linux内核中的用户态地址空间管理使用了红黑树(red-black tree)这种数据结构，我想一定有许多人在这种数据结构上感到困惑，我也曾经为此查阅了许多资料以便了解红黑树的原理。最近我在一个外国网站上看到一篇讲解红黑树的文章，觉得相当不错，不敢独享，于是翻译成中文供所有内核版的弟兄们参考。由于本人水平有限，难免有出错之处，欢迎大家指正。 原文网址：http
红黑树 插入 删除 代码实现 思想 与2-3-4树的联系 golang实现
田园园野的博客
05-24 932
介绍红黑树之前，要先了解其他几种树（二叉树，二叉排序树，平衡二叉树），红黑树就是在其他树的变形（特别是平衡二叉树，要先明白平衡二叉树，读者要先去了解一下）。一、红黑树介绍：1、性质：性质1、每个节点是红色或黑色性质2、根节点是黑色性质3、每个叶子结点（NIL）是黑色【这里的叶子结点，是指为空（NIL或NULL）的叶子结点！】性质4、如果一个节点是红色的，则它的子结点必须是黑色的性质5、从一个节点到...
golang年度使用总结，简洁不简单
alex_023的博客
07-31 7407
时间过得好快，从比较正式的使用go语言，已经差不多一年了。这期间，go从1.5发展到了1.7，自己因为兴趣+责任，来到了新的团队，再次从事曾经非常熟悉的开发工作，充实。在玩scala之后，用了go语言最初了解go语言，还是13年原单位一个项目。在不涉及到数据库操作的情况下，技术团队用.net竟然无法支持500/s的tcp峰值请求。本欲捡起Java，结果无意中知道了go。发现，用go的select非常
golang 圣诞树
12-20
以下是一个用Go语言编写的圣诞树的例子： ```go package main import ( "fmt" "strings" ) func main() { height := 5 // 圣诞树的高度 for i := 0; i ; i++ { spaces := strings.Repeat(" ", height-i-1)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值