力扣解题思路：队列与栈纠错记录

最新推荐文章于 2021-07-24 20:40:23 发布

小姬炖蘑菇o0

最新推荐文章于 2021-07-24 20:40:23 发布

阅读量213

点赞数 2

本文链接：https://blog.csdn.net/qq_39879315/article/details/107331778

版权

232. 用栈实现队列

思路：由于队列是先进先出，栈是先进后出，所以要用栈实现队列只能使用两个栈，因为执行一次出栈和入栈之后栈元素的顺序就会正好相反，所以再取出的peek就是队头啦~~

class MyQueue {

    private Stack<Integer> in = new Stack<>();
    private Stack<Integer> out = new Stack<>();

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

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

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

    private void in2out() {
        if (out.isEmpty()) {
            while (!in.isEmpty()) {
                out.push(in.pop());
            }
        }
    }

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

只要out一直不为空，out中的值就一直是队头。

225. 用队列实现栈

思路：由于队列出队再入队之后队列中的元素也会是一样的顺序，所以用过两个队列来实现栈实属没必要，所以只用一个队列就可以啦。由于队列先出来的是队头元素， 那么如何获取队尾元素呢？我们可以把除队尾的其他元素出队再入队一遍，那么对尾不就是队头了么o( ￣▽￣)ブ，悄咪咪说一句，其实LinkedList本身是可以既充当队列也充当栈的，但是初始化的时候需要写成LinkedList<> stack = new LinkedList<>()啦~
接下来我们看代码：

class MyStack {

    private Queue<Integer> queue;

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

    public void push(int x) {
        queue.add(x);
        int cnt = queue.size();
        while (cnt-- > 1) {
            queue.add(queue.poll());
        }
    }

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

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

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

是不是很简单~~

155. 最小栈

思路：这一题我一直认为是个比较简单的题，甚至比上面两个简单多了，用栈来实现栈还不简单吗？于是我使用两个栈，其中一个用来保存数据，另一个用来维护最小值：

class MinStack {    
	public Stack<Integer> a = new Stack<>();    
	public Stack<Integer> b = new Stack<>();    
/** initialize your data structure here. */    
	public MinStack() {
	    }        
	public void push(int x) {        
	    if(a.isEmpty()){            
		    a.push(x);            
		    b.push(x);        
	    }else{            
		    a.push(x);            
		    if(x<=b.peek()){                
		    b.push(x);            
	    	}        
	    }           
	}        
	public void pop() {        
	    if(a.peek().equals(b.peek())){            
	    	a.pop();            
	    	b.pop();        
	    }else{            
	    	a.pop();        
	    }    
	}        
	public int top() {        
	    return a.peek();    
	}        
	public int getMin() {        
	    return b.peek();    
	}
}

这里需要提醒的一点是，千万不要把a.peek().equals(b.peek())写成了a.peek() == b.peek()，我枯了，一开始的时候我就写的a.peek() == b.peek()一直找不到错误在哪，后来才发现这个，记住==比较的是两个地址值！即使数值一样，地址值也是可能不一样的（对于Integer和int都是！），测试用例中有出现-1024、512等超过正常int数值范围的数值，因此转integer即自动装箱时会比较地址值而不是数值！！（正常范围时-128到127之间），所以要用equals比较值！
还有另外一个比较简单的方法，再用个min维护最小值，就不需要一直比较栈顶的值啦~

class MinStack {

    private Stack<Integer> dataStack;
    private Stack<Integer> minStack;
    private int min;

    public MinStack() {
        dataStack = new Stack<>();
        minStack = new Stack<>();
        min = Integer.MAX_VALUE;
    }

    public void push(int x) {
        dataStack.add(x);
        min = Math.min(min, x);
        minStack.add(min);
    }

    public void pop() {
        dataStack.pop();
        minStack.pop();
        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
    }

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

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

还可以这样写，更容易理解：

public MinStack() {
    stack = new Stack<Integer>();
}
public void push(int x) {
    if(stack.isEmpty()){
        stack.push(x);
        stack.push(x);
    }else{
        int tmp = stack.peek();
        stack.push(x);
        if(tmp<x){
            stack.push(tmp);
        }else{
            stack.push(x);
        }
    }
}
public void pop() {
    stack.pop();
    stack.pop();
}
public int top() {
    return stack.get(stack.size()-2);
}
public int getMin() {
    return stack.peek();
}

这样比较简单是因为两个栈总是同时入栈和出栈，能保持一致。ヾ(≧▽≦*)o

面试题 03.05. 栈排序

思路：
在这里插入图片描述
这题和 232. Implement Queue using Stacks 还有 implements stack using Queues 以及 Min Stack。思考的切入角度都是一样的。具体地，就是采用增量法。就比如这题。你假设你的主stack已经是满足sorted stack 的性質了。我们需要思考的就是当你来一个新的元素的时候，怎么借用辅助栈/队列，来维持这个性质，。对于这个题目，就是你需要将比它大的元素先放到辅助栈中，然后把目标值存入主栈中，然后再把辅助栈的元素放回来（插入排序思想）：

class SortedStack {
    Deque<Integer> minStack; // 维护一个单调递增（sort in acending）/递减栈(sort in decending)，栈顶最大
    Deque<Integer> tempStack; // 辅助栈（栈能保证顺序，所以不可以用队列，不过如果是双端队列，那就当我没说）
    public SortedStack() {   
        minStack = new LinkedList<>();
        tempStack = new LinkedList<>();
    }
    public void push(int val) {
        while (!minStack.isEmpty() && minStack.peek() < val) {
            tempStack.push(minStack.pop());
        }//找到比当前数val小的位置，在他上面放入val，再把临时保存在辅助栈中的元素放上来
        minStack.push(val);
        while (!tempStack.isEmpty()) {
            minStack.push(tempStack.pop()); 
        }
    }
    public void pop() {
        if (isEmpty()) {
            return; 
        }
        minStack.pop();
    }
    public int peek() {
        if (isEmpty()) {
            return -1;
        }
        return minStack.peek();
    }
    public boolean isEmpty() {
        return minStack.isEmpty();
    }
}

剑指 Offer 59 - II. 队列的最大值

思路：在这里插入图片描述
这个题目与上面类似，但是实际上不可以用最大栈的思想，先看我的错误代码吧：

class MaxQueue {
    // 使用单调队列记录最大值即可
   LinkedList<Integer> maxQ;
    Queue<Integer> q; 
    public MaxQueue() {
        maxQ = new LinkedList<Integer>();
        q = new LinkedList<Integer>();
    }
    public int max_value() {
        if (maxQ.isEmpty()) {
            return -1;
        }
        return maxQ.peekLast();
    }
    public void push_back(int value) {
        if(q.isEmpty()){
            q.add(value);
            maxQ.add(value);
        }else{
            q.add(value);
            if(maxQ.peekLast()<value){
                maxQ.add(value);
            }else{
                maxQ.add(maxQ.peekLast());
            }
        }
    }
    public int pop_front() {
        if (q.isEmpty()) {
            return -1;
        }
        int res = q.poll();
        maxQ.poll();
        return res;
    }
}

举个例子，如果按照321入队列，那么此时maxQ应该是333，但是如果这是移除3，maxQ应该是33，那这就错了！！！！这是因为栈只有一个出入口，而队列则不是。

解决办法：

    // 使用单调队列记录最大值即可
    Deque<Integer> maxQ;
    Queue<Integer> q; 
    public MaxQueue() {
        maxQ = new LinkedList<Integer>();
        q = new LinkedList<Integer>();
    }
    public int max_value() {
        if (maxQ.isEmpty()) {
            return -1;
        }
        return maxQ.peekLast();
    }
    public void push_back(int value) {
        q.offer(value);
        while ((!maxQ.isEmpty()) && maxQ.peekFirst() < value) {
            maxQ.pollFirst();
        }
        maxQ.offerFirst(value);
    }
    public int pop_front() {
        if (q.isEmpty()) {
            return -1;
        }
        int res = q.poll();
        if (res == maxQ.peekLast()) {
            maxQ.pollLast();
        }
        return res;
    }

另外一个队列采用头插法，如果对头比它小，就将对头出队直到遇到比它大的，然后入队，那我们每次返回的最大值就是队尾（队尾最大，整个队列从前往后是递增的）。那么poll时要检查poll出的元素是否是最大队列的尾部第一个（尾部第一个是最大的），如果是则尾部出队，如果不是证明该元素早就出队了，不可能还存在于最大队列中！！

如果做过剑指 Offer 59 - I. 滑动窗口的最大值
会发现其实这一题也可以用一样的思路，也就是往队尾添加元素，对头来保持最大元素：

class MaxQueue {//和上一题思路类似
    // 使用单调队列记录最大值即可
    Deque<Integer> maxQ;
    Queue<Integer> q; 
    public MaxQueue() {
        maxQ = new LinkedList<Integer>();
        q = new LinkedList<Integer>();
    }
    public int max_value() {
        if (maxQ.isEmpty()) {
            return -1;
        }
        return maxQ.peekFirst();
    }
    public void push_back(int value) {
        q.offer(value);
        while ((!maxQ.isEmpty()) && maxQ.peekLast() < value) {
            maxQ.pollLast();
        }
        maxQ.offer(value);
    }
    public int pop_front() {
        if (q.isEmpty()) {
            return -1;
        }
        int res = q.poll();
        if (res == maxQ.peekFirst()) {
            maxQ.poll();
        }
        return res;
    }
}

224. 基本计算器

思路：实现一个基本的计算器来计算一个简单的字符串表达式的值。
字符串表达式可以包含左括号 ( ，右括号 )，加号 + ，减号 -，非负整数和空格。

输入: "(1+(4+5+2)-3)+(6+8)"
输出: 23

简单来说，这种带括号的基本上都会用到栈，这一题也是，关键在于我们栈中不仅要存储数值还有加减符号也要存，另外，遇到（时需要将之前算的结果入栈，而遇到）则将之前计算的结果出栈进行计算：

public int calculate(String s) {
    Stack<Integer> stack = new Stack<Integer>();
    // sign 代表正负
    int sign = 1, res = 0;
    int length = s.length();
    for (int i = 0; i < length; i++) {
        char ch = s.charAt(i);
        if (Character.isDigit(ch)) {
            int cur = ch - '0';
            while (i + 1 < length && Character.isDigit(s.charAt(i + 1)))
                cur = cur * 10 + s.charAt(++i) - '0';//读入的字符串数转化成数值
            res = res + sign * cur;
        } else if (ch == '+') {
            sign = 1;
        } else if (ch == '-') {
            sign = -1;
        } else if (ch == '(') {//遇到括号时，存入括号前的符号（正负号）以及括号之前算的res
            stack.push(res);
            res = 0;//存入后清0，也就是相当于接下来就是单独算括号内的数值之和
            stack.push(sign);
            sign = 1;
        } else if (ch == ')') {//遇到反括号，取出括号之前的值，以及括号之前的符号，一并运算
            res = stack.pop() * res + stack.pop();
        }
    }
    return res;
}

227. 基本计算器 II

思路：实现一个基本的计算器来计算一个简单的字符串表达式的值。
字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格。整数除法仅保留整数部分。

输入: " 3+5 / 2 "
输出: 5

这一题我想了一下不可以用上面那一题的模板，因为这里的*和/是有更高优先级的，所以不能遇到加减直接计算，而是需要看后面有没有*和/等，所以正确的方法应该是先把所有的*和/都先计算了，再把栈中的元素相加（遇到建好则存其相反数，栈中不存储符号）：

public int calculate(String s) {
    int res = 0, d = 0;//d表示每个数字及之前的符号的乘积，第一个数字之前的符号默认为+
 char sign = '+';//初始默认符号
 Stack<Integer> nums = new Stack<>();
 for (int i = 0; i < s.length(); ++i) {
     if (s.charAt(i) >= '0') {//加减乘除和空格ASCII码都小于'0'
         d = d * 10 - '0' + s.charAt(i);//进位(先减法)，每次只加一个字符而不是一个整数
     }
     if ((s.charAt(i) < '0' && s.charAt(i) != ' ') || i == s.length() - 1) {
         if (sign == '+') {
             nums.push(d);
         } else if (sign == '-') {
             nums.push(-d);
         } else if (sign == '*' || sign == '/') {
             int tmp = sign == '*' ? nums.pop() * d : nums.pop() / d;//这里觉得很奇怪，d好像并不是*或/后的数字（问题在于，sign并不是当前s.charAt(i)，而是上一次s.charAt(i-1)的符号，这次的符号s.charAt(i)在最后才赋值）
             //nums.pop();
             nums.push(tmp);
         }
         sign = s.charAt(i); //保存当前符号（赋值当前符号）
         d = 0;
     }
 }
 for (; !nums.empty(); nums.pop()) {//将每个数字以及前面的符号的乘积入栈，最后加起来的时候一起出栈相加，与之前的方法不同，之前是括号内一步步算出来相加
     res += nums.peek();
 }
 return res; 
 }

小姬炖蘑菇o0

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
力扣解题思路：队列与栈纠错记录

232. 用栈实现队列思路：由于队列是先进先出，栈是先进后出，所以要用栈实现队列只能使用两个栈，因为执行一次出栈和入栈之后栈元素的顺序就会正好相反，所以再取出的peek就是队头啦~~class MyQueue { private Stack<Integer> in = new Stack<>(); private Stack<Integer> out = new Stack<>(); public void push(int x
复制链接

扫一扫