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
}