定义栈的数据结构，请在该类型中实现一个能够得到该栈最小元素的min函数，在该栈中调用min、push及pop的时间复杂度都是O(1)

问题描述：

定义栈的数据结构，请在该类型中实现一个能够得到该栈最小元素的min函数，在该栈中调用min、push及pop的时间复杂度都是O(1)

示例：

入栈 5 3 4 1 10 最小值 10

出栈 10 1 最小值 3

解题思路：

为了保证min的时间复杂度为O(1)，所以需要借助一个新的空间存储栈的最小值，由于数据是无序的，而且时间复杂度为O(1)，所以需要单独开辟一个栈，每次插入新值以后，获取当前位置的最小值，与备份栈最新的值比较，如果最小值小于等于该值, 则存入到备份栈中，当取出数据时，与备份文件存储的数据比较，如果相等，则删除备份中的数据，结构如下：

入栈：5 -> 3 -> 4 -> 1 -> 10

备份：5 -> 3 -> 1

package main

import (
	"fmt"
	"errors"
)

type stack []int

func(s *stack) push(v int) {
	*s = append(*s, v)
}

func(s *stack) pop() (int, error) {
	v := *s
	if len(v) == 0 {
		return 0, errors.New("Out of index, len is 0")
	}
	val := v[len(v) - 1]
	*s = v[:len(v)-1]
	return val, nil
}

func(s stack) len() int {
	return len(s)
}

func(s stack) latest() (int, error) {
	if len(s) == 0 {
		return 0, errors.New("Out of index, len is 0")
	}
	return s[len(s)-1], nil
}

type Stack struct {
	value stack
	backup stack
	// 操作加锁
}

func New() *Stack{
	return &Stack{
		value: make(stack, 0),
		backup: make(stack, 0),
	}
}

func(s *Stack) Push(v int) {
	s.value.push(v)
	if s.backup.len() == 0 {
		s.backup.push(v)
	} else {
		min, _ := s.backup.latest()
		if v <= min {
			s.backup.push(v)
		}
	}
	
}

func(s *Stack) Pop() (int, error) {
	v, err := s.value.pop()
	if err != nil {
		return 0, err
	}
	min, _ := s.backup.latest()
	if v == min {
		_, _ = s.backup.pop()
	} 
	return v, nil
}

func (s *Stack) Min() (int, error) {
	v, err := s.backup.latest()
	if err != nil {
		return 0, err
	}
	return v, nil
}

func main() {
	stack := New()
	stack.Push(5)
	stack.Push(3)
	stack.Push(4)
	stack.Push(1)
	stack.Push(10)
	min, _ := stack.Min()
	fmt.Println("min: ", min)
	stack.Pop()
	stack.Pop()
	stack.Pop()
	min1, _ := stack.Min()
	fmt.Println("min: ", min1)
}