2021-3-23 栈 和 队列（JAVA 实现）

栈 和 队列

=================================================
栈：

1. 基础

   栈是一种特殊的线性表，栈的插入和删除是在表的尾端进行。先入栈的是元素放在栈底，成为栈底元素；先出栈的在栈顶位置，即栈顶元素。栈是后进先出(LOFI)，或者先进后出（FILO)。

2. 基本操作：
   （1）判断空栈 isEmpty （）；
   （2）入栈 push（）；//将数据 X 压入栈顶
   （3）出栈 pop（）；//删除并返回数据；
   （4）查看栈顶元素 peek（）；//查看栈顶元素， 不删除

队列：

1. 基础
   队列也是一种特殊线性表，队列只允许在表尾插入数据元素，在表头删除数据元素。队列是要求先进先出（FIFO）。

2. 基本操作：
   （1）判断为空 isEmpty（）；
   （2）入队 add（）；
   （3）出队 remove（）；
   （4）查看队首元素 element（）：

================================================
代码实现：

1.用队列实现栈
力扣225题：

1.思考
push：选择有元素的队；加入元素；
pop：选择有元素的队；将size-1 元素移入另一队中；剩余元素出；
peek：选择一个有元素的队；将size-1 元素移入另一队中；剩余元素返回并放另一队中；

2.代码部分

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
   Queue<Integer> queue1 = new LinkedList<>();
   Queue<Integer> queue2 = new LinkedList<>();

    /** Initialize your data structure here. */
    public MyStack() {
    }

    /** Push element x onto stack. */
    public void push(int x) {
        Queue<Integer> queue = new LinkedList<>();
        if(!queue1.isEmpty()){
            queue = queue1;
        }else if(!queue2.isEmpty()){
            queue=queue2;
        }else{
            queue = queue1;
        }
        queue.add(x);
    }

    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        Queue<Integer> queue = new LinkedList<>();
        Queue<Integer> toqueue = new LinkedList<>();
        if(!queue1.isEmpty()){
            queue = queue1;
        }else if(!queue2.isEmpty()){
            queue=queue2;
        }else{
            queue = queue1;
        }
        int size = queue.element();
        for (int i =0;i<size-1;i++){
            int e =queue.remove();
            toqueue.add(e);
        }
        return queue.remove();
    }

    /** Get the top element. */
    public int top() {
        Queue<Integer> queue = new LinkedList<>();
        Queue<Integer> toqueue = new LinkedList<>();
        if(!queue1.isEmpty()){
            queue = queue1;
        }else if(!queue2.isEmpty()){
            queue=queue2;
        }else{
            queue = queue1;
        }
        int size = queue.element();
        for (int i =0;i<size-1;i++){
            int e =queue.remove();
            toqueue.add(e);
        }
        int f  = queue.remove();
        toqueue.add(f);
        return f;
    }

    /** Returns whether the stack is empty. */
    public boolean empty() {
    return queue1.isEmpty()&& queue2.isEmpty();
    }
}

2.对栈实现队列

力扣232题

1.思考
需要两个栈，分别标记为stack1、 stack2；
push：数据存入stack2 中；
pop：当stack1 为空，stack2 出元素放入stack1 中；
peek：只看不出；

2.代码部分

public class Solution {
   Stack<Integer> stack1 = new Stack<>();
   Stack<Integer> stack2 = new Stack<>();
    /** Initialize your data structure here. */
    public MyQueue() {

    }

    /** Push element x to the back of queue.
     * @return*/
    public void push(int x) {

        stack2.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        if (stack1.isEmpty()){
            while (!stack2.isEmpty()){
                int e = stack2.pop();
                stack1.push(e);
            }
        }
        return stack1.pop();
    }

    /** Get the front element. */
    public int peek() {
        if (stack1.isEmpty()){
            while (!stack2.isEmpty()){
                int e = stack2.pop();
                stack1.push(e);
            }
        }
        return stack1.peek();
    }

    /** Returns whether the queue is empty. */
    public boolean empty() {
        return stack1.isEmpty()&& stack2.isEmpty();
    }
}