java算法oj（3）栈和队列

队列是一种先进先出的数据结构。这意味着第一个插入的元素会是第一个被移除的元素。队列的基本操作包括：

offer(value)：将元素插入到队列的尾部（如果队列未满）。

poll()：移除并返回队列头部的元素（如果队列不为空）。

peek()：返回队列头部的元素但不移除它（如果队列不为空）。

isEmpty()：检查队列是否为空。

2.2用栈实现队列

2.2.1题目

测试链接 : 232. 用栈实现队列 - 力扣（LeetCode）

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

实现 MyQueue 类：

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

说明：

你只能使用标准的栈操作 ------ 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

2.2.2示例

2.2.3代码

这道题如果有了思路实现起来就会比较容易。这道题的关键就在于如何仅通过栈先进后出结构实现队列的先进先出的结构，这里的解法就是通过利用俩个栈来模拟队列，看示意图：

创建一个in栈和out栈，先将123压入in栈中。

再将in栈中的元素压入out栈中。最后对out中的元素进行pop，peek等操作就是和队列一样，接下来附上代码：

java 复制代码

import java.util.Stack;

class MyQueue {

    public Stack<Integer> in;

    public Stack<Integer> out;

    public MyQueue() {
        in = new Stack<Integer>();
        out = new Stack<Integer>();
    }

    private void inout(){
        if(out.empty()){
            while(!in.empty()){
                out.push(in.pop());
            }
        }
    }

    public void push(int x) {
        in.push(x);
        inout();
    }

    public int pop() {
        inout();
        return out.pop();
    }

    public int peek() {
        inout();
        return out.peek();
    }

    public boolean empty() {
        return in.isEmpty() && out.isEmpty();
    }
}

2.3用队列实现栈

2.3.1题目

测试链接 :225. 用队列实现栈 - 力扣（LeetCode）

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

实现 MyStack 类：

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

注意：

你只能使用队列的标准操作 ------ 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

2.3.2示例

2.3.3代码

如何仅使用队列的操作来实现栈呢，看示意图：

当队列仅有这一个元素时，此时此队列也满足栈的结构，但如果压入俩个元素该如何处理呢？

我们将2压入队列后，将1压出队列再压入队列，此时队列中的2，1满足栈的要求。

同理如果再压入3，将3前面的2，1都进行一次压入压出操作最后变成：

代码实现如下：

java 复制代码

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

class MyStack {

    Queue <Integer>queue;

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

    public void push(int x) {
        int n = queue.size();
        queue.offer(x);
        for(int i = 0;i < n;i++){
            queue.offer(queue.poll());
        }
        n++;
    }

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

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

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

2.4最小栈

2.4.1题目

测试链接 :155. 最小栈 - 力扣（LeetCode）

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

2.4.2示例

2.4.3代码

这道题的思路时用一个栈来存储，另一个栈用来实时标记当前栈最小值，这样就不用循环遍历，时间复杂度高了，代码实现如下：

java 复制代码

import java.util.Stack;

class MinStack {
    Stack<Integer> stack;
    Stack<Integer> stackmin;


    public MinStack() {
        stack = new Stack<Integer>();
        stackmin = new Stack<Integer>();
    }

    public void push(int val) {
        if(stack.empty()||val < stackmin.peek()){
            stack.push(val);
            stackmin.push(val);
        }
        else{
            stack.push(val);
            stackmin.push(stackmin.peek());
        }
    }

    public void pop() {
        stack.pop();
        stackmin.pop();
    }

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

    public int getMin() {
        return stackmin.peek();
    }
}

3.小结

今天的分享到这里就结束了，喜欢的小伙伴不要忘记点点赞点个关注，你的鼓励就是对我最大的支持，加油！