Go语言：如何仅用递归函数和栈操作逆序一个栈

【题目】：
一个栈依次压入1，2，3，4，5，那么从栈顶到栈底分别为5，4，3，2，1。
将这个栈转置后，从栈顶到栈底为1，2，3，4，5，也就是实现栈中元素的逆序，
但是只能用递归函数来实现，不能用其他数据结构。

本题的要求是用一个栈，如果用两个栈解决该问题，就更简单了。本题还有其他的解法。先记录一种常见的解法。
解法一：
设计两个递归函数：

func getAndRemoveLastElement(t *Stack) (r interface{})

func Reverse(t *Stack) 

全部代码：

package main

import (
	"fmt"
	"log"
)

type Stack struct {
	size int64 //容量
	top	 int64 //栈顶
	data []interface{}
}

func MakeStack(size int64) Stack {
	q := Stack{}
	q.size = size
	q.data = make([]interface{}, size)
	return q
}

//入栈
func (t *Stack) Push(element interface{}) bool {
	if t.isFull() {
		log.Printf("log栈已满，无法完成入栈")
		return false
	}
	t.data[t.top] = element
	t.top++
	return true
}

//出栈
func (t *Stack) Pop() (r interface{}, err error) {
	if t.isEmpty() {
		err = fmt.Errorf("栈已满，无法完成入栈")
		log.Println("栈已满，无法完成入栈")
		return
	}
	t.top--
	r = t.data[t.top]
	return
}

//栈长度
func (t *Stack) StackLength() int64 {
	return t.top
}

//清空
func (t *Stack) Clear() {
	t.top = 0
}

//判空
func (t *Stack) isEmpty() bool {
	return t.top == 0
}

//判满
func (t *Stack) isFull() bool {
	// fmt.Printf("t.top:%d, t.size:%d\n", t.top, t.size)
	return t.top == t.size
}

//遍历
func (t *Stack) Traverse(fn func(node interface{}), isTop2Bottom bool) {
    if !isTop2Bottom {
        var i int64 = 0
        for ; i < t.top; i++ {
            fn(t.data[i])
        }
    } else {
        for i := t.top - 1; i >= 0; i-- {
            fn(t.data[i])
        }
    }
}

func getAndRemoveLastElement(t *Stack) (r interface{}) {
	result, _ := t.Pop()
	if t. isEmpty() {
		return result
	} else {
		last := getAndRemoveLastElement(t)
		t.Push(result)
		return last
	}
}

func Reverse(t *Stack)  {
	if t.isEmpty() {
		return
	}
	v := getAndRemoveLastElement(t)
	Reverse(t)
	t.Push(v)
}

func main() {
	size := int64(5)
	q := MakeStack(size)
	q.Push(1)
	q.Push(2)
	q.Push(3)
	q.Push(4)
	q.Push(5)

	fmt.Println("---After Reverse---")
	q.Traverse(func(node interface{}) {
			fmt.Println(node)
			}, true)

    Reverse(&q)

    fmt.Println("---After Reverse---")
	q.Traverse(func(node interface{}) {
		fmt.Println(node)
		}, true)
}

运行结果：

---Original Stack---
5
4
3
2
1
---After Reverse---
1
2
3
4
5

参考：https://blog.csdn.net/gooaaee/article/details/80817230