Golang随机删除元素

index = m[C] // 获取元素C在heap的下标
return h[index] // 获取index在heap的值

index = m[C] // 获取元素C在heap的下标
swap(index, n - 1) // 和最后一个元素交换
pop() // 移除最后一个元素，也就是元素C
down(index) // 从index向下调整堆
up(index) // 从index向上调整堆

h[i], h[j] = h[j], h[i] // 交换堆中两个元素
m[h[i].Key] = i // 交换map元素索引
m[h[j].Key] = j // 交换map元素索引

elem = h.removeLast() // 移除最后一个元素
m.remove(elem.Key) // 移除元素索引

m[key] = n // 添加元素索引
h.addLast(Entry(K, V)) // 添加元素到堆

type Meap[K comparable, V any] struct {
	h        []Entry[K, V]
	m        map[K]int
	lessFunc LessFunc[K, V]
}

type Entry[K comparable, V any] struct {
	Key   K
	Value V
}

type LessFunc[K comparable, V any] func(e1 Entry[K, V], e2 Entry[K, V]) bool

func (h *Meap[K, V]) Pop() Entry[K, V] {
	n := h.Len() - 1
	h.swap(0, n) // 堆顶和最后一个元素交换
	h.down(0, n) // 调整堆
	return h.pop() // 移除堆中最后一个元素
}

func (h *Meap[K, V]) Push(key K, value V) {
	// 如果堆中已经包含这个元素
	// 更新值并调整堆
	if h.Contains(key) {
		index := h.m[key] // 元素在堆中下标
		h.h[index].Value = value // 更新堆中元素值
		h.fix(index) // 向上向下调整堆
		return
	}

	// 否则添加元素
	h.push(key, value) // 添加元素到堆的最后面
	h.up(h.Len() - 1) // 向上调整堆
}

func (h *Meap[K, V]) Remove(key K) {
	i, ok := h.m[key] // 获取元素在堆中下标
	if !ok { // 如果元素不存在则直接返回
		return
	}

	n := h.Len() - 1 // 最后一个元素索引
	if n != i { // 如果被移除的元素就是堆中最后一个元素，则没必要调整了，直接移除即可
		h.swap(i, n) // 和最后一个元素交换
		if !h.down(i, n) { // 向下调整
			h.up(i) // 向上调整
		}
	}
	h.pop() // 移除堆中最后一个元素
}

// swap两个元素的时候
// 两个元素在map里的下标也要交换
func (h *Meap[K, V]) swap(i, j int) {
	h.h[i], h.h[j] = h.h[j], h.h[i] // 交换两个元素
	h.m[h.h[i].Key] = i // 更新索引
	h.m[h.h[j].Key] = j // 更新索引
}

// 添加一个元素到堆的末尾
func (h *Meap[K, V]) push(key K, value V) {
	h.m[key] = h.Len() // 添加索引
	h.h = append(h.h, Entry[K, V]{ // 添加元素到堆尾
		Key:   key,
		Value: value,
	})
}

// 从堆的末尾移除元素
func (h *Meap[K, V]) pop() Entry[K, V] {
	elem := h.h[h.Len()-1] // 堆尾元素
	h.h = h.h[:h.Len()-1] // 移除堆尾元素
	delete(h.m, elem.Key) // 删除堆尾元素索引
	return elem
}