LeetCodeday09

232.用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

用两个栈实现，一个进栈，一个出栈，加入元素时，就忘进栈加入，弹出元素时，将进栈所有元素加入到出栈，从出栈弹出元素

public class Leetcode232 {
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue();
        // queue is: [1]
        myQueue.push(1);
        // queue is: [1, 2] (leftmost is front of the queue)
        // return 1
        System.out.println("myQueue.peek() = " + myQueue.peek());
        // return 1, queue is [2]
        System.out.println("myQueue.pop() = " + myQueue.pop());
        myQueue.push(2);
        // return false
        System.out.println("myQueue.empty() = " + myQueue.empty());
    }
}

class MyQueue {
    Stack<Integer> stackIn;
    Stack<Integer> stackOut;

    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }

    public void push(int x) {
        stackIn.push(x);

    }

    /**
     * 移除 队首元素
     *
     * @return 队首元素
     */
    public int pop() {
        // stackOut 为空 将 stackIn中元素 全部放到 stackOut中
        if (stackOut.isEmpty()) {
            while (!stackIn.isEmpty()) {
                stackOut.push(stackIn.pop());
            }
        }
        return stackOut.pop();
    }

    /**
     * 返回 队首元素
     * @return 队首元素
     */
    public int peek() {
        if (stackOut.isEmpty()) {
            while (!stackIn.isEmpty()) {
                stackOut.push(stackIn.pop());
            }
        }
        return stackOut.peek();
    }

    public boolean empty() {
        return stackOut.isEmpty() && stackIn.isEmpty();
    }
}

225. 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

public class Leetcode225 {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push(1);
        myStack.push(2);
        // 返回 2
        System.out.println("myStack.top() = " + myStack.top());
        // 返回 2
        System.out.println("myStack.pop() = " + myStack.pop());
        // 返回 False
        System.out.println("myStack.empty() = " + myStack.empty());
    }
}

class MyStack {
    Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();
    }

    public void push(int x) {
        queue.offer(x);
        // 每加入一个元素 就将该元素放到队首
        int size = queue.size();
        while (size-- > 1) {
            Integer fist = queue.poll();
            queue.offer(fist);
        }
    }

    /**
     * 移除 并返回栈顶元素。
     *
     * @return x
     */
    public int pop() {
        return queue.poll();
    }

    public int top() {
        return queue.peek();
    }

    public boolean empty() {
        return queue.isEmpty();
    }
}