1. 基于切片的实现

package main

import (
	"fmt"
)

var stackArray []interface{} //创建一个接口类型的切片 可以保存任何类型的元素
var a []int

func push(x interface{}) {
	stackArray = append(stackArray, x) //加入x
}
func pop() interface{} {
	sz := len(stackArray)          //获取栈大小
	ele := stackArray[sz-1]        //最后1个元素是栈顶元素   [0-n-1]--[栈底-栈顶]
	stackArray = stackArray[:sz-1] //删除最后一个元素（栈顶元素）
	return ele
}
func peek() interface{} {
	return stackArray[length()-1] //返回栈顶元素
}
func length() int {
	return len(stackArray)
}
func isEmpty() bool {
	return length() == 0
}
func main() {
	push(1)
	push(2)
	push(3)
	fmt.Println(stackArray)
	fmt.Println(pop())
	fmt.Println(peek())
	push("hello")
	push(3.14)
	fmt.Println(peek())
	fmt.Println(pop())
	fmt.Println(peek())

}

2. 基于链表的实现

package main

import (
	"fmt"
)

type Node struct {
	Val  interface{}
	Next *Node
}
type Stack struct {
	top *Node
	sz  int
}

func (st *Stack) push(x interface{}) {
	newNode := &Node{} //创建一个新节点
	newNode.Val = x
	newNode.Next = st.top
	st.top = newNode //栈顶指针指向新节点
	st.sz++
}
func (st *Stack) pop() interface{} {
	ele := st.top.Val
	st.top = st.top.Next
	st.sz--
	return ele
}
func (st *Stack) peek() interface{} {
	ele := st.top.Val
	return ele
}
func (st *Stack) size() int {
	return st.sz
}
func (st *Stack) isEmpty() bool {
	return st.size() == 0
}
func (st *Stack) show() {

	for cur := st.top; cur != nil; cur = cur.Next {
		fmt.Print(cur.Val)
		if cur.Next != nil {
			fmt.Print("<-")
		}
	}
	fmt.Println()
}
func main() {
	st := &Stack{}
	st.push("aaa")
	st.push("bbb")
	st.push("ccc") //  "ccc"->"bbb"->"aaa"  "ccc"是栈顶元素 相当于push时是链表的头插法
	st.show()
	fmt.Println(st.size())
	fmt.Println(st.pop())
	fmt.Println(st.pop())
	fmt.Println(st.size())
	fmt.Println(st.pop())
	fmt.Println(st.isEmpty())

}
/*ccc<-bbb<-aaa
3
ccc
bbb
1
aaa
true
*/