代码随想录算法训练营第十天|● 理论基础● 232.用栈实现队列● 225. 用队列实现栈

 不管你是用栈实现队列，还是队列实现栈。都需要调用java内部的栈或者队列去实现，所以说，java内部的Collection接口类，还是得掌握熟练。

栈的基本方法
1.push(Object item)：将元素item压入栈顶。
2.pop()：弹出栈顶元素，并将其从栈中删除。
3.peek()：返回栈顶元素，但不删除它。
4.isEmpty()：判断栈是否为空，返回布尔值。
5.search(Object item)：搜索元素item在栈中的位置（从栈顶开始），如果找到则返回其距离栈顶的位置（栈顶为1），如果未找到则返回-1。
6.clear()：对当前栈进行清空。
————————————————

● 232.用栈实现队列

两个问题，

1、你一开始构造两个栈，一定要定义成类变量，而不是局部变量

2、你这几段代码全使用了同一段代码，应该重新构建一个函数，提高复用。

class MyQueue {
    Stack<Integer> temp;//
    Stack<Integer> stack;//这两句一定要写在public MyQueue外面，要不然你调用temp和stack的时候会报错
    //您的代码中有一个问题是在构造函数和其他方法中创建的temp和stack对象是局部变量，而不是类的成员变量。这意味着它们只能在构造函数中访问，而其他方法无法访问它们。因此，您应该将它们声明为类的成员变量。这样，所有方法都可以访问它们。
    public MyQueue() {
        temp = new Stack<>();
        stack = new Stack<>();
    }
    
    public void push(int x) {
        temp.push(x);
        if (stack.isEmpty()){
            while (!temp.isEmpty()){
                stack.push(temp.pop());
            }
        }
    }
    
    public int pop() {
        if (stack.isEmpty()){
            while (!temp.isEmpty()){
                stack.push(temp.pop());
            }
        }
        return stack.pop();
    }
    
    public int peek() {
        if (stack.isEmpty()){
            while (!temp.isEmpty()){
                stack.push(temp.pop());
            }
        }
        return stack.peek();
    }
    
    public boolean empty() {
        if (stack.isEmpty()){
            while (!temp.isEmpty()){
                stack.push(temp.pop());
            }
        }
        return stack.isEmpty();
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

class MyQueue {
    Stack<Integer> temp;//
    Stack<Integer> stack;//这两句一定要写在public MyQueue外面，要不然你调用temp和stack的时候会报错
    //您的代码中有一个问题是在构造函数和其他方法中创建的temp和stack对象是局部变量，而不是类的成员变量。这意味着它们只能在构造函数中访问，而其他方法无法访问它们。因此，您应该将它们声明为类的成员变量。这样，所有方法都可以访问它们。
    public MyQueue() {
        temp = new Stack<>();
        stack = new Stack<>();
    }
    
    public void push(int x) {
        temp.push(x);
        dump();
    }
    
    public int pop() {
        dump();
        return stack.pop();
    }
    
    public int peek() {
        dump();
        return stack.peek();
    }
    
    public boolean empty() {
        return temp.isEmpty() && stack.isEmpty();
    }
    private void dump(){
        if (stack.isEmpty()){
            while (!temp.isEmpty()){
                stack.push(temp.pop());
            }
        }
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

● 225. 用队列实现栈

我觉得人家这个思路很好，push的时候只要进来一个数字（A），全部重新排列，把（A）放到队列的队首。

这样的话pop和top都不用额外写了。

（1）添加元素：

boolean add(E element): 将指定的元素添加到队列的末尾，如果成功则返回true，如果队列已满则抛出异常。
boolean offer(E element): 将指定的元素添加到队列的末尾，如果成功则返回true，如果队列已满则返回false。

（2）移除元素：

E remove(): 移除并返回队列头部的元素，如果队列为空则抛出异常。
E poll(): 移除并返回队列头部的元素，如果队列为空则返回null。

（3）获取头部元素：

E element(): 获取队列头部的元素，但不移除它，如果队列为空则抛出异常。
E peek(): 获取队列头部的元素，但不移除它，如果队列为空则返回null。

（4）队列大小：

int size(): 返回队列中的元素个数。
boolean isEmpty(): 判断队列是否为空。

class MyStack {
    Queue<Integer> queue;
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.add(x);//每 offer 一个数（A）进来，都重新排列，把这个数（A）放到队列的队首
        int size = queue.size();
        //移动除了 A 的其它数
        while (size-- > 1){
            queue.offer(queue.poll());
        }
    }
    
    public int pop() {
        return queue.poll();
    }
    
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */