定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

package main

import "fmt"

/**
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
解：用一个辅助栈
如下：3 4 2 5 1
     3 2 1

 */
func main() {
   for _,i := range [] int{3,4,2,5,1} {
      push(i)
   }

   fmt.Println(getmin())
   for i:=0;i<=2;i++  {
      fmt.Print(*pop())
      fmt.Print(getmin())
      fmt.Println()
   }

}

type Stack struct {
   data []int
}

var s Stack
var f Stack
var slen int
var flen int

func getmin() int {
   //辅助栈栈顶即为最小元素
   if 0 == flen{
      return 0
   }
   return f.data[flen - 1]
}

func push(d int) {
   //元素小于等于辅助栈元素的时候，辅助栈入栈
   s.data = append(s.data, d)
   slen ++

   if 0 == flen {
      f.data = append(f.data, d)
      flen ++
      return
   }

   if d <= f.data[flen-1] {
      f.data = append(f.data, d)
      flen ++
   }

}

func pop() *int {
   //当两个栈 栈顶元素相同的时候，辅助栈元素出栈
   if nil == &s {
      return nil
   }


   slen = len(s.data)
   flen = len(f.data)

   if nil != &s {
      if s.data[slen-1] == f.data[flen-1] {
         flen --
         f.data = f.data[0:flen]
      }
   }

   res := s.data[slen-1]
   slen --
   s.data = s.data[:slen]

   return &res
}