栈和队列：互相实现（go）

用栈实现队列

问题描述：

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

思路：

因为go语言没有栈的结构体，直接用一维切片模拟栈。
stack：进入的栈，
back： 输出的栈
push：直接导入
pop：判断当前输出栈是否为空，不为空直接导出，为空将stack导入进back
empty：直接判断两个栈是否为空
代码：

//结构体，包含两个一维切片
type MyQueue struct {
    stack []int
    back []int
}

//初始化，
func Constructor() MyQueue {
    return MyQueue {
        stack: make([]int ,0 ),
        back: make([]int, 0),
    }
}


func (this *MyQueue) Push(x int)  {
    this.stack = append(this.stack,x)
}


func (this *MyQueue) Pop() int {
    if len(this.back) == 0 {
        for len(this.stack) != 0 {
            val := this.stack[len(this.stack)-1]
            this.stack = this.stack[:len(this.stack)-1] //切片，更新栈
            this.back = append(this.back, val)
        }
    }
    val := this.back[len(this.back)-1]
    this.back = this.back[:len(this.back)-1]
    return val
}


func (this *MyQueue) Peek() int {
    // this.
    if len(this.back) == 0 {
        for len(this.stack) != 0 {
            val := this.stack[len(this.stack)-1]
            this.stack = this.stack[:len(this.stack)-1]
            this.back = append(this.back, val)
        }
    }
    val := this.back[len(this.back)-1]
    return val
}


func (this *MyQueue) Empty() bool {
    return len(this.back)==0 && len(this.stack)==0
}

用队列实现栈

问题描述：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

思路：

同理，go也没有队列的结构体，直接干。
可以使用一个队列，将除了尾部元素都移到尾部。

代码：

type MyStack struct {
    que []int
}


func Constructor() MyStack {
    return MyStack {
        que: make([]int, 0),
    }
}


func (this *MyStack) Push(x int)  {
    this.que= append(this.que,x)
}


func (this *MyStack) Pop() int {
    l := len(this.que)-1
    for l>0 {
        tem := this.que[0]
        this.que = this.que[1:]
        this.que = append(this.que,tem) 
        l--
    }
    res := this.que[0]
    this.que = this.que[1:]
    return res
}


func (this *MyStack) Top() int {
    // return this.que[len(this.que)-1]
    val := this.Pop()
    this.que = append(this.que,val)
    return val
}


func (this *MyStack) Empty() bool {
    return len(this.que) ==0
}