golang红黑树

最新推荐文章于 2024-07-26 10:06:23 发布
最新推荐文章于 2024-07-26 10:06:23 发布
阅读量587 收藏
点赞数
分类专栏： 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实现的红黑树
闷骚的Gopher
04-13 4008
红黑树是一种基于
golang 红黑树map实现
sky_terra的专栏
06-11 790
//------------------------------------------------------------------------------ // rbtree.go // 红黑树 //------------------------------------------------------------------------------ package rbmap const ( RED bool = true BLACK bool = false ) type no.
探索高效数据结构的魅力：Rbtree——Golang中的红黑树实现
gitblog_00043的博客
06-22 265
探索高效数据结构的魅力：Rbtree——Golang中的红黑树实现 项目地址:https://gitcode.com/HuKeping/rbtree 在软件开发的浩瀚宇宙中，数据结构犹如基石，支撑着算法与应用的高效运行。今天，我们聚焦于一款专为Golang设计的红黑树(Red-Black Tree)实现——Rbtree，它以简洁优雅的方式带来了高性能的关键字搜索和数据管理能力。 1. 项目介绍 R...
红黑树详解及实现(golang)
weixin_46041797的博客
09-29 988
参考 插入过程参考《STL源码剖析》 删除过程参考《算法导论》以及博客：红黑树的删除操作 源码实现参考nginx中红黑树的实现和《STL源码剖析》 红黑树的定义 学习、理解红黑树时，必须时紧紧刻围绕着红黑树的定义 以下是《STL源码剖析》中给出的定义： 根节点是黑色 每个节点非红即黑 如果一个节点为红色，它的子节点必为黑色 任何一个节点至NULL（树尾端）的任何路径，所含黑节点数必须相同 红黑树的节点的定义 type RbTreeColor bool type RbTreeKeyType int t
Golang实现红黑树
只数月亮不数星星的博客
05-02 4230
红黑树基于golang的实现，主要介绍如何实现红黑树的调整。在此中加入了自己在实现过程中的些许感受和在处理逻辑时需要注意的细节。
golang 手撕红黑树
l1002544188的博客
03-21 1265
GOLANG 手撕红黑树 前言 GOLANG表中包中自带的数据结构比较少，目前找到的红黑树都是开源实现，索性自己手撕一颗来练练手。以下主要讲解代码实现。 github地址:https://github.com/Julius-Li/daily/tree/master/rbtree 红黑树简单介绍 红黑树是一种不严格平衡二叉树，通过**保持其性质**就能保持整个树的平衡。红黑...
go语言的map以及红黑树的map
papaya的博客
05-06 3121
结论： 1. go语言自带的map是基于hash表实现的 2. c++语言中map是基于红黑树实现的 3. go语言很多第三方库中提供了基于红黑树map的实现 这里我们推荐的是由Social Explorer团队开源的gods框架，简称"上帝"，其实是GoDS(Go Data Structures)，是数据结构与算法相关的框架 官网：https://www.socialexplor...
【Golang 数据结构与法算】 红黑树
qq_37981903的博客
12-23 454
GitHub完整代码 完整代码 package tree import ( "data-structures-and-algorithms/contract" "data-structures-and-algorithms/queue" "fmt" "strings" ) // RedBlack 红黑树（4路平衡搜索树） // 红黑树约束（规定了红黑树的渐进平衡性）： // (1) 树根始终为黑色 // (2) 外部节点均为黑色 // (3) 其余节点若为红色，则其孩子节点必为黑色 /.
红黑树原理详解及golang实现
weixin_30512089的博客
06-02 400
目录 红黑树原理详解及golang实现 二叉查找树 性质 红黑树 性质 operation 红黑树的插入 golang实现 类型定义 leftRotate ...
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等等。。。
TreeSet 红黑树结构算法
11-08
TreeSet 红黑树结构算法 TreeSet 红黑树结构算法是 Java 中的一种数据结构，它是基于红黑树数据结构的实现。红黑树是一种自平衡的排序二叉树，它可以保证快速检索指定节点。TreeSet 和 TreeMap 之间存在着紧密的...
golang_algorithm
03-17
在Go语言中，常见的数据结构包括数组、链表、队列、栈、哈希表、树（如二叉树、AVL树、红黑树）等。这些数据结构在不同的场景下有着各自的优势，例如，数组适合于随机访问，链表适合于动态插入和删除，哈希表则提供...
Golang 泛型详解
07-25 867
/ 自定义一个新类型 MapTT：类型形参。定义 MapT 时 T 代表的类型并不确定，类似一个占位符。：类型约束。指定 T 仅可接受哪些类型。中括号内定义形参类型，称为形参类型列表。其中，类型约束可以包上 interface{}m[T] = valreturn m// 或简写为type T interface{int|int32|float32|string} // 自定义类型约束。
go语言day18 reflect反射
weixin_45939821的博客
07-25 1182
获取Value对象时使用指针，让Value中存储的是personObj对象属性的地址，才能修改personObj对象属性；同样都是获取类型，Kind()获取go包中已存在的类型，对于自定义的结构体类型只会显示struct.显示具体类型使用reflect.TypeOf()否则默认会浅拷贝一个对象，修改属性跟原对象不相干。
【VSCode实战】Golang无法跳转问题竟是如此简单
最新发布
weixin_42206314的博客
07-26 841
workspace是golang1.18版本引入的新概念，就是VSCode打开的工作目录中，若是有多个mod文件，它会不知道使用哪一个，也就无法定位。但工作目录中，若是只有一个项目，那么它自然可以找到，也就可以正常“转到定义”。，开头说到了在VSCode中Golang无法跳转的问题，但文章的最后也没给出解决方案，只解决了安装Go插件的依赖问题。2.在已安装的扩展里面，找到Go扩展，点击右下角的齿轮标记，选择扩展设置，也会打开1的界面。无法跳转的问题，其实还是很简单的，只是被网上各种冗余信息误导了。
golang 圣诞树
12-20
以下是一个用Go语言编写的圣诞树的例子： ```go package main import ( "fmt" "strings" ) func main() { height := 5 // 圣诞树的高度 for i := 0; i < height; i++ { spaces := strings.Repeat(" ", height-i-1) stars := strings.Repeat("*", 2*i+1) fmt.Println(spaces + stars) } trunkSpaces := strings.Repeat(" ", height-1) fmt.Println(trunkSpaces + "|") } ``` 运行上述代码，将会输出一个高度为5的圣诞树的图案： ``` * *** ***** ******* ********* | ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值