算法训练营 day10 栈与队列 理论基础 用栈实现队列 用队列实现栈

算法训练营 day10 栈与队列 理论基础 用栈实现队列 用队列实现栈

栈与队列理论基础

栈

​ 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈中的元素总是遵循后进先出LIFO（Last In First Out）的原则。

java标准库中提供的栈

实现的方法

方法	功能
Stack（）	创建空堆栈
E push（E ）	将对象添加到堆栈顶部
E pop （）	删除此堆栈顶部的对象
E peek（）	查看此堆栈顶部的对象
boolean empty（）	测试此堆栈是否为空。
int search（Object）	返回对象在此堆栈上的位置（从1开始）。

队列

​ 队列是一种特殊的线性表。特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列中的元素总是遵循先进先出FIFO(First In First Out)的原则。

java标准库中提供的队列

实现的方法

方法	功能
boolean add（E）	添加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
boolean offer（E）	添加一个元素并返回true 如果队列已满，则返回false
E remove()	移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
E poll()	移除并返问队列头部的元素 如果队列为空，则返回null
E element()	返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
E peek()	返回队列头部的元素 如果队列为空，则返回null

双端队列

Deque（java.util.Deque）接口代表着双向队列，意思就是可以从队列的两端增加或者删除元素，Deque就是双向Queue的意思。

用栈实现队列

232. 用栈实现队列 - 力扣（LeetCode）

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

实现 MyQueue 类：

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

使用栈来模式队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈一个输入栈，一个输出栈，这里要注意输入栈和输出栈的关系。

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

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

    public int pop() {
        dumpstackIn();
        return stackOut.pop();
    }

    public int peek() {
        dumpstackIn();
        return stackOut.peek();
    }

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

    public void dumpstackIn(){
        if (!stackOut.isEmpty()) return;
        while (!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

用队列实现栈

225. 用队列实现栈 - 力扣（LeetCode）

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

实现 MyStack 类：

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

1、两个队列

class MyStack {
    Queue<Integer> que1;
    Queue<Integer> que2;
    public MyStack() {
        que1 = new LinkedList<>();
        que2 = new LinkedList<>();
    }

    public void push(int x) {
        que1.offer(x);
    }

    public int pop() {
        int size  = que1.size();
        size--;
        while (size-->0){
            que2.offer(que1.poll());
        }
        int result = que1.poll();
        while (!que2.isEmpty()){
            que1.offer(que2.poll());
        }
        return result;
    }

    public int top() {
        int size  = que1.size();
        size--;
        while (size-->0){
            que2.offer(que1.poll());
        }
        int result = que1.peek();
        que2.offer(que1.poll());
        while (!que2.isEmpty()){
            que1.offer(que2.poll());
        }
        return result;
    }

    public boolean empty() {
        return  que1.isEmpty()&&que2.isEmpty();
    }
}

2、两个队列优化

class MyStack {
    Queue<Integer> que1;
    Queue<Integer> que2;
    public MyStack() {
        que1 = new LinkedList<>();
        que2 = new LinkedList<>();
    }

    public void push(int x) {
        que2.offer(x);
        while (!que1.isEmpty()){
            que2.offer(que1.poll());
        }
        Queue<Integer> temp;
        temp = que1;
        que1 = que2;
        que2 = temp;
    }

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

    public int top() {

        return que1.peek();
    }

    public boolean empty() {
        return  que1.isEmpty()&&que2.isEmpty();
    }
}

其实这道题目就是用一个队列就够了。

一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时再去弹出元素就是栈的顺序了。

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)
            queue.offer(queue.poll());
    }

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

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

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