Golang 基于数组、链表实现栈

下面基于数组和链表实现的自定义栈，只有简单的功能

• Top() 返回栈顶元素
• Pop() 元素出栈
• Push(data int) 元素入栈

package main

type stack interface {
	Top() int
	Pop() int
	Push(data int)
}

type Liststack struct {
	data []int
	size int
	lock sync.Mutex
}

type LinkStack struct {
	root *LinkNode
	size int
	lock sync.Mutex
}

func NewListstack() *Liststack {
	return &Liststack{
		data: make([]int, 0),
		size: 0,
		lock: sync.Mutex{},
	}
}

func NewLinkStack() *LinkStack {
	return &LinkStack{
		root: nil,
		size: 0,
		lock: sync.Mutex{},
	}
}

func (ls *Liststack) Top() int {
	if ls.data == nil || len(ls.data) == 0 {
		log.Panic("当前栈是空的")
	}
	return ls.data[ls.size-1]
}

func (ls *Liststack) Pop() int {

	ls.lock.Lock()
	defer ls.lock.Unlock()

	if ls.data == nil || len(ls.data) == 0 {
		log.Panic("当前栈是空的")
	}

	ls.size--
	last := ls.data[ls.size]
	ls.data = ls.data[:ls.size]
	return last
}

func (ls *Liststack) Push(data int) {
	ls.lock.Lock()
	defer ls.lock.Unlock()

	ls.data = append(ls.data, data)
	ls.size++
}

type LinkNode struct {
	data int
	next *LinkNode
}

func (ls *LinkStack) Top() int {
	if ls.root == nil {
		log.Panic("当前栈是空的")
	}
	return ls.root.data
}

func (ls *LinkStack) Pop() int {

	ls.lock.Lock()
	defer ls.lock.Unlock()

	if ls.root == nil {
		log.Panic("当前栈是空的")
	}
	current := ls.root
	ls.root = current.next
	ls.size--
	return current.data
}

func (ls *LinkStack) Push(data int) {

	ls.lock.Lock()
	defer ls.lock.Unlock()

	node := &LinkNode{
		data: data,
		next: nil,
	}

	if ls.root == nil {
		ls.root = node
	} else {
		current := ls.root
		node.next = current

		ls.root = node
	}
	ls.size++
}

func main() {
	ls := NewLinkStack()
	ls.Push(10)
	ls.Push(20)
	ls.Push(30)
	ls.Push(40)
	ls.Push(50)
	ls.Push(60)

	fmt.Printf("lick stack size: %d\n", ls.size)
	ls.Pop()
	ls.Pop()
	ls.Pop()
	fmt.Printf("lick stack size: %d\n", ls.size)
}