day10|栈与队列

● 理论基础

栈—先进后出

常用栈的类Stack
常用方法：

• push(T v)：向栈中压入元素
• T peek()：获取栈顶元素
• T pop()：弹出栈顶元素并返回栈顶元素

队列—先进先出

Queue

Queue是LinkedList的向上转型，是标准队列，一头进另一头出

Queue相关方法：

offer(T v)：将数据插入到队尾
T peek()：返回对头元素，队空时返回null
T element()：返回对头元素，队空时，抛出NoSuchElementException异常
T poll()：移除队头元素并返回队头元素，队空时返回null
T remove()：移除队头元素并返回队头元素，队空时抛出NoSuchElementException异常

ArrayDeque

ArrayDeque是java中对双端队列的线性实现
ArrayDeque 作为 队列（FIFO） 使用时的方法：

添加元素

addFirst(T v) 向队尾插入元素;
addLast(T v) 向队头插入元素
offerFirst(T v) 向队尾插入元素，插入成功返回true，插入失败，返回NoSuch
offerLast(T v) 向队头插入元素，插入成功返回true，插入失败，返回NoSuch

删除元素

T pollFirst() 删除队头元素，并返回队头元素。队空时，返回null
T removeFirst() 删除队头元素。队空时，抛出异常
T pollLast() 删除队尾元素，并返回队头元素。队空时，返回null
T removeLast() 删除队尾元素。队空时，抛出异常

获取元素

T peekFirst() 获取队头元素，队空返回null
T getFirst() 获取队头元素，队空抛出异常
T peekLast() 获取队尾元素，队空返回null
T getLast() 获取队尾元素，队空抛出异常

● 232.用栈实现队列

力扣链接
实现思路
使用两个栈完成，一个栈作为入栈栈，一个作为出栈栈

• 元素入队列时，使用栈模拟：元素进入入栈栈
• 元素出队列时，出栈栈不为空，直接pop栈顶元素；出栈栈为空，将入栈栈中的所有元素依次导入到出栈栈当中，再pop出栈栈顶元素
• 获取队头元素：出栈栈不为空，直接返回栈顶元素；出栈栈为空，将入栈栈中的所有元素依次导入到出栈栈当中，返回出栈栈栈顶元素
• 判断队列是否为空：入栈栈和出栈栈均为空时，断定队列为空
  实现过程

import java.util.Stack;
//请你仅使用两个栈实现先入先出队列。
//队列应当支持一般队列支持的所有操作（push、pop、peek、empty）
public class MyQueue {
    Stack<Integer> staIn = new Stack<>();
    Stack<Integer> staOut = new Stack<>();
    public MyQueue() {

    }

    public void push(int x) {
        staIn.push(x);
    }

    public int pop() {
        //判断staOut栈是否为空
        //不为空：直接返回出栈的栈顶元素
        //为空：将staIn栈中的全部元素依次导入到staOut中
        if(staOut.empty()){
            while(!staIn.empty()){
                int temp = staIn.pop();
                staOut.push(temp);
            }
        }
        return staOut.pop();
    }

    public int peek() {
        int res = pop();
        staOut.push(res);
        return res;
    }

    public boolean empty() {
        if(staOut.empty()&& staIn.empty()){
            return true;
        }
        return false;
    }
}

● 225. 用队列实现栈

力扣链接

实现思路：

• 元素入栈：元素进入队列，将队列中前n-1个元素依次移到队列末尾，使第n个元素置于队头
• 获取栈顶元素：直接返回队头元素
• 删除栈顶元素：poll出队头元素
• 判断栈是否为空：队列为空栈就为空

难度：

元素入栈时调用移动元素方法，使得元素只移动依次即可
获取栈顶元素和删除元素时移动元素，应题目要求，对内的元素会被移动两次，不符合结果

实现过程

使用标准队列Queue

import java.util.ArrayDeque;
import java.util.Queue;
//请你仅使用两个队列实现一个后入先出（LIFO）的栈，
// 并支持普通栈的全部四种操作（push、top、pop 和 empty）
public class MyStack {
    Queue<Integer> queue = new ArrayDeque<>();
    int size = 0;

    public MyStack() {

    }

    public void push(int x) {
        queue.offer(x);
        size++;
        removeEmp(queue);
    }

    public int pop() {
        return queue.poll();
    }

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

    public boolean empty() {
        return queue.isEmpty();
    }
    public void removeEmp(Queue<Integer> que){
        int i= 0;
        while(i<que.size()-1){
            int emp =  que.poll();
            i++;
            que.offer(emp);
    }
}