golang用数组模拟出栈，入栈...

栈的概念：栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶（top），相对地，把另一端称为栈底(bottom)。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

注意：栈遵循先进后出原则；栈顶，栈底刚开始的默认值为-1，

用golang的数组模拟出栈入栈代码展示：

package utils

import (
	"fmt"
	"errors"
)

type Stack struct{
	MaxTop int  //最大可以存放的个数
	Top int //栈顶
	Arr [5]int //模拟栈的数组
}

//入栈
func (this *Stack) Push(val int) (err error){
	if this.MaxTop - 1 == this.Top{
		return errors.New("Full Stack")
	}

	this.Top++
	this.Arr[this.Top] = val
	return
}

//出栈
func (this *Stack) Pop() (val int, err error){
	if this.Top == -1 {
		return -1, errors.New("Empty Stack")
	}

	val = this.Arr[this.Top]
	this.Top--
	return
}

//栈列表
func (this *Stack) List() (err error){
	if this.Top == -1 {
		return errors.New("Empty Stack")
	}

	for i := this.Top; i >= 0; i-- {
		fmt.Printf("栈列表: arr[%d] => %d \t", i, this.Arr[i])
	}
	fmt.Println()
	return
}

测试代码：

stack := &utils.Stack{
        MaxTop : 5,
        Top : -1,
    }

    for i := 1; i <= 5; i++{
        err := stack.Push(i)
        if err == nil {
            fmt.Println("入栈成功 <==", i)
        }else{
            fmt.Println("入栈错误，err=", err)
        }
    }

    stack.List()

    for {
       val, err := stack.Pop()
       if err == nil{
           fmt.Println("出栈 ==>：", val)
       }else{
           fmt.Println("已到达栈底， err=", err)
           break
       }
    }

切片实现出栈入栈：

package main

import "fmt"

type Stack struct {
    data []int
}

// 入栈
func (s *Stack) Push(val int) {
    s.data = append(s.data, val)
}

// 出栈
func (s *Stack) Pop() (int, bool) {
    if len(s.data) == 0 {
        return 0, false
    }
    top := s.data[len(s.data)-1]
    s.data = s.data[:len(s.data)-1]
    return top, true
}

// 获取栈顶元素
func (s *Stack) Top() (int, bool) {
    if len(s.data) == 0 {
        return 0, false
    }
    return s.data[len(s.data)-1], true
}

// 判断栈是否为空
func (s *Stack) IsEmpty() bool {
    return len(s.data) == 0
}