Go语言container/heap包：优先级队列实现中的指针接收器与接口陷阱

type Interface interface {
    sort.Interface // Len, Less, Swap
    Push(x interface{})
    Pop() interface{}
}

package pq

import "fmt" // 仅为示例中的调试输出

type Item struct {
    container interface{}
    priority  int
    index     int
}

type PriorityQueue []*Item // 优先级队列基于切片实现

func NewItem(value interface{}, prio int) *Item {
    return &Item{container: value, priority: prio}
}

// Len, Less, Swap 方法通常可以使用值接收器
func (pq PriorityQueue) Len() int {
    return len(pq)
}

func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].priority > pq[j].priority // 示例为最大堆
}

func (pq PriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
    pq[i].index = i
    pq[j].index = j
}

// Push 方法使用值接收器 (错误示例)
func (pq PriorityQueue) Push(x interface{}) {
    fmt.Printf("Push method receiver address: %p\n", &pq) // 调试输出
    n := len(pq)
    item := x.(*Item)
    item.index = n
    pq = append(pq, item) // ⚠️ 此处修改的是pq的副本
}

// Pop 方法使用值接收器 (错误示例)
func (pq PriorityQueue) Pop() interface{} {
    old := pq
    n := len(old)
    itm := old[n-1]
    itm.index = -1
    pq = old[0 : n-1] // ⚠️ 此处修改的是pq的副本
    return itm.container
}

package main

import (
    "container/heap"
    "fmt"
    "your_module/pq" // 假设pq包在your_module下
)

func main() {
    q := pq.PriorityQueue{} // q是一个值类型
    heap.Init(q)            // ⚠️ 传递的是q的值副本
    fmt.Printf("\nMain queue address: %p\n", &q)

    q.Push(pq.NewItem("h", 2)) // ⚠️ 调用的是pq.PriorityQueue的值方法，修改的是副本

    for i := 0; i < 5; i++ {
        item := pq.NewItem("test", i*13%7)
        heap.Push(q, item) // ⚠️ 传递的是q的值副本，heap.Push内部调用的是接口方法
    }

    for q.Len() > 0 {
        // ... (此处会因为堆为空而panic或不输出任何内容)
    }
}

package main

import (
    "container/heap"
    "fmt"
)

// Item 定义了优先级队列中的元素
type Item struct {
    container interface{} // 实际存储的数据
    priority  int         // 元素的优先级
    index     int         // 元素在堆中的索引，用于更新优先级
}

// NewItem 是创建新Item的辅助函数
func NewItem(value interface{}, prio int) *Item {
    return &Item{container: value, priority: prio}
}

// PriorityQueue 是基于切片实现的优先级队列
type PriorityQueue []*Item

// Len 返回队列的当前长度
func (pq PriorityQueue) Len() int {
    return len(pq)
}

// Less 比较两个元素的优先级。此处实现为最大堆（priority值越大优先级越高）
func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].priority > pq[j].priority
}

// Swap 交换两个元素的位置，并更新它们的索引
func (pq PriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
    pq[i].index = i
    pq[j].index = j
}

// Push 将一个元素添加到优先级队列中。必须使用指针接收器来修改底层切片。
func (pq *PriorityQueue) Push(x interface{}) {
    // fmt.Printf("Push method receiver address: %p\n", pq) // 调试输出
    n := len(*pq)
    item := x.(*Item)
    item.index = n
    *pq = append(*pq, item) // 修改指针指向的底层切片
}

// Pop 从优先级队列中移除并返回优先级最高的元素。必须使用指针接收器来修改底层切片。
func (pq *PriorityQueue) Pop() interface{} {
    old := *pq
    n := len(old)
    item := old[n-1] // 取出最后一个元素
    item.index = -1  // 标记为已移除
    *pq = old[0 : n-1] // 截断切片，移除最后一个元素
    return item.container
}

func main() {
    // 方式一：使用new()创建PriorityQueue的指针
    q := new(PriorityQueue) // q 现在是一个指向PriorityQueue的指针
    heap.Init(q)            // 直接传递指针

    fmt.Printf("\nMain queue address: %p\n", q)
    q.Push(NewItem("Initial item 'h'", 2)) // 直接调用指针接收器的方法

    for i := 0; i < 5; i++ {
        item := NewItem(fmt.Sprintf("test-%d", i), i*13%7)
        heap.Push(q, item) // 传递指针给heap.Push
    }

    fmt.Println("\nPopping elements from the priority queue:")
    for q.Len() > 0 {
        fmt.Printf("Item: %v (Priority: %d)\n", heap.Pop(q).(*Item).container, heap.Pop(q).(*Item).priority) // 注意：这里连续Pop了两次，实际使用时应Pop一次并保存结果
    }

    // 修正后的Pop循环示例
    fmt.Println("\nCorrected popping elements from the priority queue:")
    // 重新填充队列以便演示
    q = new(PriorityQueue) // 重置队列
    heap.Init(q)
    q.Push(NewItem("Initial item 'h'", 2))
    for i := 0; i < 5; i++ {
        heap.Push(q, NewItem(fmt.Sprintf("test-%d", i), i*13%7))
    }

    for q.Len() > 0 {
        item := heap.Pop(q).(*Item) // Pop一次，保存结果
        fmt.Printf("Item: %v (Priority: %d)\n", item.container, item.priority)
    }

    // 方式二：声明一个值类型，然后传递其地址
    var q2 PriorityQueue
    heap.Init(&q2) // 传递q2的地址

    q2.Push(NewItem("Another initial item", 10)) // 直接调用指针接收器的方法
    heap.Push(&q2, NewItem("item-x", 5))         // 传递q2的地址给heap.Push

    fmt.Println("\nPopping elements from q2:")
    for q2.Len() > 0 {
        item := heap.Pop(&q2).(*Item)
        fmt.Printf("Item: %v (Priority: %d)\n", item.container, item.priority)
    }
}