goland里面的堆，栈，队列

goland里面的堆，栈，队列

go语言里面都没有像java里面有现成的set，stack,和优先队列，都需要自己去实现或者封装contain下的list和heap,然后再使用，set的话使用map。
Java里面的优先队列是很好用的，要是面试写LeetCode，可以考虑放弃goland语言，使用java
直接看代码

package main

import (
	"container/heap"
	"container/list"

	//"container/list"
	"fmt"
)


type StringHeap []string

func (h StringHeap) Len() int {
	//panic("implement me")
	return len(h)
}

func (h StringHeap) Less(i, j int) bool {
	//panic("implement me")
	return h[i]>h[j]
}

func (h StringHeap) Swap(i, j int) {
	//panic("implement me")
	h[i],h[j]=h[j],h[i]
}

func (h *StringHeap)Push(x interface{})  {
	*h=append(*h,x.(string))
}
func (h *StringHeap)Pop()(x interface{})  {
	old:=*h
	*h=old[1:len(old)]
	heap.Init(h)
	return old[0]
}
func main()  {
	//heap必须继承len less swap函数
	h:=&StringHeap{
		"811",
		"4",
		"2",
		"3",
		"7",
		"6",
		"1",
		"5",
		"5",
		"-1",
		"a",
		"b",
	}
	heap.Init(h)
	heap.Push(h,"0")
	//heap.Fix(h,1),fix用于个人手动更改数组的某i下标的元素后进行重新堆排序，但该节点的内排序，
	fmt.Println("a">"b")
	for h.Len()>0 {
		fmt.Println(h.Pop())

		//heap.Init(h)//可用重新初始化代替下面的,这个也可以放进实现的pop函数里面
		
	}
	//heap.Fix()
	//栈，需要用list进行封装
	fmt.Println("栈")
	stack:=NewStack()
	stack.Push(1)
	stack.Push(11)
	stack.Push(111)
	for stack.Len()>0 {
		fmt.Println(stack.Pop())
	}

}


type Stack struct {
	list *list.List
}

func NewStack() *Stack {
	list := list.New()
	return &Stack{list}
}

func (stack *Stack) Push(value interface{}) {
	stack.list.PushBack(value)
}

func (stack *Stack) Pop() interface{} {
	e := stack.list.Back()
	if e != nil {
		stack.list.Remove(e)
		return e.Value
	}
	return nil
}

func (stack *Stack) Peak() interface{} {
	e := stack.list.Back()
	if e != nil {
		return e.Value
	}

	return nil
}

func (stack *Stack) Len() int {
	return stack.list.Len()
}

func (stack *Stack) Empty() bool {
	return stack.list.Len() == 0
}

结果：