Go 栈的实现

package main

import (
   "errors"
   "fmt"
)

type Stacker struct{
   Val interface{}
   Next *Stacker
}

func Push(head *Stacker,arrval []byte) ( *Stacker, ){
   //node := Stacker{nil,nil}
   p := head
   for {
      if p.Next==nil{
         break
      }
      p=p.Next
   }
   for i:=0;i<len(arrval) ;i++  {
      node :=Stacker{arrval[i],nil}
      p.Next = &node
      p =p.Next
   }
   return head
}

func Pop(head *Stacker)(Stacker,error){
   if head.Next==nil{
      //fmt.Println("stacker empty")
      return Stacker{},errors.New("stacker empty")
   }
   p :=head
   pop := Stacker{nil,nil}
   for{
      if p.Next.Next==nil{
         pop = *p.Next
         p.Next=nil
         return pop,nil
      }
      p=p.Next
   }
}

func StackerLength(head *Stacker)int{
   length :=0
   p := head
   for {
      p = p.Next
      if p==nil{
         return length
      }
      length++
   }
}

func StackerIsEmpty(head *Stacker)bool{
   if StackerLength(head)==0{
      return true
   }else{
      return false
   }
}

func GetTop(head *Stacker)(Stacker,error){
   if head.Next==nil{
      //fmt.Println("stacker empty")
      return Stacker{},errors.New("stacker empty")
   }
   p :=head
   for{
      if p.Next==nil{
         return *p,nil
      }
      p=p.Next
   }
}

func main(){
   stack := &Stacker{nil,nil}
   //tail  := &Stacker{nil,nil}
   arrval := []byte{'a','b','c','d','e'}
   stack = Push(stack,arrval)
   node,_ :=GetTop(stack)
   fmt.Printf("%v",node)
}