|
|
golang 在container包下提供了list（双链表）、heap（堆）、ring（环）等容器结构
|
|
|
![[Pasted image 20231225085517.png]]
|
|
|
# 一、list
|
|
|
golang 中实现的list为双向链表。双向链表一般用于经常堆头部和尾部进行增删的场景，同时它不需要在一开始初始化它的容量，它的容量随着使用动态变化（扩大or缩小）。
|
|
|
核心数据结构(Element、List)：
|
|
|
```golang
|
|
|
// 链表的一个元素
|
|
|
type Element struct {
|
|
|
next, prev *Element // 前后指针
|
|
|
list *List // 所属链表
|
|
|
Value any // 值
|
|
|
}
|
|
|
```
|
|
|
|
|
|
```golang
|
|
|
// 链表
|
|
|
type List struct {
|
|
|
root Element // 哨兵元素
|
|
|
len int // 链表元素个数
|
|
|
}
|
|
|
```
|
|
|
![[Pasted image 20231225170420.png]]
|
|
|
|
|
|
## 1.初始化
|
|
|
```golang
|
|
|
package main
|
|
|
|
|
|
import (
|
|
|
"container/list"
|
|
|
"fmt"
|
|
|
)
|
|
|
func main()
|
|
|
// 使用list.New()直接初始化
|
|
|
l1 := list.New()
|
|
|
l1.PushFront(1)
|
|
|
fmt.Println(l1.Front().Value) // 1
|
|
|
|
|
|
// 使用list.List{}延迟初始化
|
|
|
l2 := list.List{}
|
|
|
l2.PushFront(2)
|
|
|
fmt.Println(l2.Front().Value) // 2
|
|
|
}
|
|
|
```
|
|
|
|
|
|
## 2.常用API
|
|
|
+ PushFront 链表头部添加元素
|
|
|
+ PushBack 尾部添加元素
|
|
|
+ PushFrontList 链表头部插入链表
|
|
|
+ PushBackList 尾部插入链表
|
|
|
+ Front 获取头部元素
|
|
|
+ Back 获取尾元素
|
|
|
+ Len 获取长度
|
|
|
+ InsertBefore 某个元素前插入
|
|
|
+ InsertAfter 某个元素后插入
|
|
|
+ MoveBefore 移动元素到某个元素前面
|
|
|
+ MoveAfter 移动元素到某个元素后面
|
|
|
+ MoveToFront 移动元素到头部
|
|
|
+ MoveToBack 移动元素到尾部
|
|
|
|
|
|
# 二、heap
|
|
|
堆是一颗完全二叉树，按照比较规则不同，分为最大堆和最小堆。以最小堆为例，父节点总是比子节点小。
|
|
|
堆的下标公式：
|
|
|
parent(i)=floor((i-1)/2) 向下取整
|
|
|
left(i)=2i+1
|
|
|
right(i)=2i+2
|
|
|
|
|
|
golang 提供了最小堆算法，其中包含5个接口需要开发者自行实现（**作为官方包，Golang 希望提供给大家一种简单的接入方式，官方提供好算法的内核，大家接入就 ok。采用的是定义一个接口，开发者来实现的方式**）
|
|
|
```golang
|
|
|
type Interface interface {
|
|
|
sort.Interface
|
|
|
Push(x any) // 入堆
|
|
|
Pop() any // 出堆
|
|
|
}
|
|
|
|
|
|
type Interface interface {
|
|
|
Len() int //堆大小
|
|
|
Less(i, j int) bool //比较
|
|
|
Swap(i, j int) //交换
|
|
|
}
|
|
|
```
|
|
|
## 例一：最小堆
|
|
|
```golang
|
|
|
package mycontainer
|
|
|
|
|
|
type IntHeap []int
|
|
|
|
|
|
// Push IntHeap全局共享切只有一个，所以需要对类型本身进行操作，所以使用指针
|
|
|
func (h *IntHeap) Push(x any) {
|
|
|
//append需要传入切片，切片是引用传递所以需要*h,
|
|
|
*h = append(*h, x.(int))
|
|
|
}
|
|
|
|
|
|
// Pop
|
|
|
//
|
|
|
// @Description: 从数组移除一个元素
|
|
|
// @receiver h
|
|
|
// @return any
|
|
|
func (h *IntHeap) Pop() any {
|
|
|
old := *h
|
|
|
n := len(old)
|
|
|
x := old[n-1]
|
|
|
*h = old[0 : n-1]
|
|
|
return x
|
|
|
}
|
|
|
|
|
|
// Len
|
|
|
//
|
|
|
// @Description: 计算元素大小
|
|
|
// @receiver h
|
|
|
// @return int
|
|
|
func (h IntHeap) Len() int {
|
|
|
return len(h)
|
|
|
}
|
|
|
|
|
|
// Less
|
|
|
//
|
|
|
// @Description: 比较大小
|
|
|
// @receiver h
|
|
|
// @param i
|
|
|
// @param j
|
|
|
// @return bool
|
|
|
func (h IntHeap) Less(i, j int) bool {
|
|
|
return h[i] < h[j]
|
|
|
}
|
|
|
|
|
|
// Swap
|
|
|
//
|
|
|
// @Description: 交换i,j下标元素
|
|
|
// @receiver h
|
|
|
// @param i
|
|
|
// @param j
|
|
|
func (h IntHeap) Swap(i, j int) {
|
|
|
h[i], h[j] = h[j], h[i]
|
|
|
}
|
|
|
|
|
|
|
|
|
// TestIntHeap
|
|
|
//
|
|
|
// @Description: 测试自定义堆
|
|
|
// @param t
|
|
|
func TestIntHeap(t *testing.T) {
|
|
|
//因为pop和push方法需要传入指针
|
|
|
h := &myc.IntHeap{7, 9, 10}
|
|
|
print(h)
|
|
|
//堆初始化，用于构建二叉树
|
|
|
heap.Init(h)
|
|
|
//添加元素
|
|
|
heap.Push(h, 3)
|
|
|
fmt.Printf("minimum: %d\n", (*h)[0])
|
|
|
for h.Len() > 0 {
|
|
|
fmt.Printf("%d ", heap.Pop(h))
|
|
|
}
|
|
|
}
|
|
|
```
|
|
|
|
|
|
## 例二：优先队列
|
|
|
```golang
|
|
|
type Item struct {
|
|
|
value string
|
|
|
priority int
|
|
|
index int
|
|
|
}
|
|
|
|
|
|
type PriorityQueue []*Item
|
|
|
|
|
|
func (p *PriorityQueue) Push(x any) {
|
|
|
n := len(*p)
|
|
|
item := x.(*Item)
|
|
|
item.index = n
|
|
|
*p = append(*p, item)
|
|
|
}
|
|
|
|
|
|
func (p *PriorityQueue) Pop() any {
|
|
|
old := *p
|
|
|
n := len(old)
|
|
|
item := old[n-1]
|
|
|
item.index = -1
|
|
|
*p = old[0 : n-1]
|
|
|
return item
|
|
|
}
|
|
|
|
|
|
func (p PriorityQueue) Len() int {
|
|
|
return len(p)
|
|
|
}
|
|
|
|
|
|
func (p PriorityQueue) Less(i, j int) bool {
|
|
|
return p[i].priority > p[j].priority
|
|
|
}
|
|
|
|
|
|
func (p PriorityQueue) Swap(i, j int) {
|
|
|
p[i], p[j] = p[j], p[i]
|
|
|
p[i].index = i
|
|
|
p[j].index = j
|
|
|
}
|
|
|
|
|
|
// 更新元素优先级
|
|
|
func (p *PriorityQueue) update(item *Item, value string, priority int) {
|
|
|
item.value = value
|
|
|
item.priority = priority
|
|
|
//二叉堆重排序
|
|
|
heap.Fix(p, item.index)
|
|
|
}
|
|
|
```
|
|
|
# 三、ring |
