golang优先队列

参考博客：https://studygolang.com/articles/13173

基本类型排序

package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
    intList := []int{, , , , , , , , , }
    floatList := []float64{4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}
    stringList := []string{"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}
 
    sort.Sort(sort.IntSlice(intList))
    sort.Sort(sort.Float64Slice(floatList))
    sort.Sort(sort.StringSlice(stringList))
 
    fmt.Printf("%v\n%v\n%v\n", intList, floatList, stringList)
 
    sort.Sort(sort.Reverse(sort.IntSlice(intList)))
    sort.Sort(sort.Reverse(sort.Float64Slice(floatList)))
    sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
 
    fmt.Printf("%v\n%v\n%v\n", intList, floatList, stringList)
}

结构体排序

package main
 
import (
    "fmt"
    "sort"
)
 
type Person struct {
    Name string // 姓名
    Age  int    // 年纪
}
 
// 按照 Person.Age 从大到小排序
type PersonSlice []Person
 
func (a PersonSlice) Len() int { // 重写 Len() 方法
    return len(a)
}
func (a PersonSlice) Swap(i, j int) { // 重写 Swap() 方法
    a[i], a[j] = a[j], a[i]
}
func (a PersonSlice) Less(i, j int) bool { // 重写 Less() 方法， 从小到大排序
    return a[i].Age < a[j].Age
}
 
func main() {
    people := []Person{
        {"zhang san", },
        {"li si", },
        {"wang wu", },
        {"zhao liu", },
    }
 
    fmt.Println(people)
 
    sort.Sort(PersonSlice(people)) // 按照 Age 的升序排序
    fmt.Println(people)
 
    sort.Sort(sort.Reverse(PersonSlice(people))) // 按照 Age 的降序排序
    fmt.Println(people)
 
}

最小堆

heap是常用的实现优先队列的方法。heap包对任意实现了heap接口的类型提供堆操作。堆结构继承自sort.Interface, 而sort.Interface，需要实现三个方法：Len() int / Less(i, j int) bool / Swap(i, j int) 再加上堆接口定义的两个方法：Push(x interface{}) / Pop() interface{}。故只要实现了这五个方法，便定义了一个堆。

package main
 
import (
    "container/heap"
    "fmt"
)
 
type IntHeap []int
 
func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
 
func (h *IntHeap) Push(x interface{}) {
    *h = append(*h, x.(int))
}
 
func (h *IntHeap) Pop() interface{} {
    old := *h
    n := len(old)
    x := old[n-]
    *h = old[ : n-]
    return x
}
 
func main() {
    h := &IntHeap{, , , , , , , }
    heap.Init(h)
    heap.Push(h, )
    fmt.Printf("minimum: %d\n", (*h)[])
    for h.Len() >  {
        fmt.Printf("%d ", heap.Pop(h))
    }
}

优先队列

package main
 
import (
    "container/heap"
    "fmt"
)
 
type stu struct {
    name string
    age  int
}
type Stu []stu
 
func (t *Stu) Len() int {
    return len(*t) //
}
 
func (t *Stu) Less(i, j int) bool {
    return (*t)[i].age < (*t)[j].age
}
 
func (t *Stu) Swap(i, j int) {
    (*t)[i], (*t)[j] = (*t)[j], (*t)[i]
}
 
func (t *Stu) Push(x interface{}) {
    *t = append(*t, x.(stu))
}
 
func (t *Stu) Pop() interface{} {
    n := len(*t)
    x := (*t)[n-]
    *t = (*t)[:n-]
    return x
}
 
func main() {
    student := &Stu{{"Amy", }, {"Dav", }, {"Spo", }, {"Reb", }}
    heap.Init(student)
    one := stu{"hund", }
    heap.Push(student, one)
    for student.Len() >  {
        fmt.Printf("%v\n", heap.Pop(student))
    }
 
}