golang实现stack的操作
本文内容纲要：
-栈的Golang实现过程
-自己写的
-参考网络一
-参考网络资源二
-godoc的参考代码实现
栈的Golang实现过程
自己写了一个Stack的实现方式，三种方法
自己写的
通过golang的slice方式实现，偏向结构化的方式实现；
funcPushS(s*[]int,vint){
fmt.Printf("%p,%p\n",s,*s)
*s=append(*s,v)
}
funcPopS(s*[]int)int{
iflen(*s)==0{
return0
}
len:=len(*s)
fmt.Println("lenofstack",len)
v:=(*s)[len-1]
*s=(*s)[:len-1]
returnv
}
funcmain(){
stack:=make([]int,0)
PushS(&stack,5)
PushS(&stack,10)
v:=PopS(&stack)
fmt.Println(v,stack)
}
参考网络一
通过对象的方式实现
typestack[]int
func(sstack)Push(vint)stack{
returnappend(s,v)
}
func(sstack)Pop()(stack,int){
l:=len(s)
ifl==0{
returns,0
}
returns[:l-1],s[l-1]
}
funcmain(){
s:=make(stack,0)
s=s.Push(10)
s=s.Push(11)
s=s.Push(12)
fmt.Println(s)
s,v:=s.Pop()
s,v=s.Pop()
fmt.Println(s,v)
s,v=s.Pop()
fmt.Println(s,v)
}
参考网络资源二
增加lock模式这样在多协程的方式下也能正常处理；
typestkstruct{
locksync.Mutex
s[]int
}
funcNewStk()*stk{
return&stk{sync.Mutex{},make([]int,0)}
}
func(s*stk)Push(vint){
s.lock.Lock()
defers.lock.Unlock()
s.s=append(s.s,v)
}
func(s*stk)Pop()(int,error){
s.lock.Lock()
s.lock.Unlock()
len:=len(s.s)
iflen==0{
return-1,errors.New("EmptyStack")
}
v:=s.s[len-1]
s.s=s.s[:len-1]
returnv,nil
}
funcmain(){
fmt.Println("hellogo")
s:=NewStk()
s.Push(10)
s.Push(11)
s.Push(12)
fmt.Println(s.s)
vv,_:=s.Pop()
vv,_=s.Pop()
fmt.Println(s.s,vv)
}
godoc的参考代码实现
type(
Stackstruct{
top*node
lengthint
}
nodestruct{
valueinterface{}
prev*node
}
)
//Createanewstack
funcNew()*Stack{
return&Stack{nil,0}
}
//Returnthenumberofitemsinthestack
func(this*Stack)Len()int{
returnthis.length
}
//Viewthetopitemonthestack
func(this*Stack)Peek()interface{}{
ifthis.length==0{
returnnil
}
returnthis.top.value
}
//Popthetopitemofthestackandreturnit
func(this*Stack)Pop()interface{}{
ifthis.length==0{
returnnil
}
n:=this.top
this.top=n.prev
this.length--
returnn.value
}
//Pushavalueontothetopofthestack
func(this*Stack)Push(valueinterface{}){
n:=&node{value,this.top}
this.top=n
this.length++
}
本文内容总结：栈的Golang实现过程，自己写的，参考网络一，参考网络资源二，godoc的参考代码实现，
原文链接：https://www.cnblogs.com/gpan/p/9836119.html