代码随想录Day11

题目列表

• 232.用栈实现队列(LeetCode)
• 225.用队列实现栈(LeetCode)
• 20.有效的括号(LeetCode)
• 1047.删除字符串中的所有相邻重复项(LeetCode)

解题过程

232.用栈实现队列

题目描述

解题思路

栈是先进后出的结构，队列是先进先出的结构，也就是说队列的pop()操作第一个弹出的应该是最早进去的，要用栈实现队列，就要想办法按进入顺序拿到元素。可以使用两个栈，一个入栈用于实现push(),另一个出栈与入栈一起实现pop(),要执行pop操作的时候，应该把push到入栈的元素依次弹出再放入出栈里，然后出栈再执行pop,这样就实现了队列的特性。

注意事项

peek()函数只是取到“队列”的第一个元素，而不是让它弹出队列。

代码展示

class MyQueue {

    Stack<Integer> stackIn;
    Stack<Integer> stackOut;

    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    
    public void push(int x) {
        stackIn.push(x);
    }
    
    public int pop() {
        transposition(stackIn,stackOut);
        return stackOut.pop();
    }
    
    public int peek() {
        transposition(stackIn,stackOut);
        int res = stackOut.pop();
        stackOut.push(res);
        return res;
    }
    
    public boolean empty() {
        if(stackIn.empty() && stackOut.empty()){
            return true;
        }
        return false;
    }
    public void transposition(Stack<Integer> stackIn, Stack<Integer> stackOut){
        if(!stackOut.empty()) return;
        while(!stackIn.empty()){
            stackOut.push(stackIn.pop());
        }
    }
}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

225.用队列实现栈

题目描述

解题思路

队列一直是先进先出的，如果要对应栈，那就是最先出队列的元素是最后出栈的元素，最后出队列元素是最先出栈的元素。由此可以知道，要模拟出栈，就要把除了队列最后一个元素以外的元素都出队列并保存，然后弹出最后一个元素就是要出栈的元素。
考虑到队列先进先出的特性，前面那些出队列的元素可以直接保存在原队列中，只使用一个队列就可以了。

代码展示

class MyStack {
     Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.add(x);
    }
    
    public int pop() {
        transposition(queue);
        return queue.poll();
    }
    
    public int top() {

        int res = this.pop();
        queue.add(res);
        return res;
    }
    public void transposition(Queue<Integer> queue){
        int size = queue.size();
        while(size > 1){
            queue.add(queue.poll());
            size -- ;
        }
    }
    
    public boolean empty() {
        if(queue.isEmpty()){
            return true;
        }
        return false;
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

20.有效的括号

题目描述

解题思路

所有花里胡哨的不匹配情况可以归为三种：

1. 左括号多余
2. 右括号多余
3. 括号数量匹配但是类型不匹配
   这三种情况可以混合出现，但是判断是可以覆盖这三种情况的。
   遇到各种类型的左括号就把对应类型的右括号压到栈里去，遇到右括号就看栈的情况，如果当前栈为空，或者栈顶和当前右括号不一致，直接返回false,对应着第二和三的情况。其他正确匹配的情况都要把当前栈顶弹出去。
   遍历一遍之后，如果栈不为空，直接返回false,这时对应第一种情况。为空返回true.

代码展示

class Solution {
    public boolean isValid(String s) {
        char[] ch = s.toCharArray();
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i < ch.length; i++){
            if(ch[i] == '(') stack.push(')');
            else if(ch[i] == '{'){
                stack.push('}');
            }
            else if(ch[i] == '['){
                stack.push(']');
            }
            else if(stack.isEmpty() || ch[i] != stack.peek()){

                return false;
            }
            else stack.pop();
        }
        return stack.isEmpty();
    }
}

1047.删除字符串中的所有相邻重复项

题目描述

解题思路

比较简单，可以使用栈这种结构。不断地把字符串的字符按顺序压栈，如果待入栈字符和栈顶字符一样，那么弹出栈顶，继续判断下一个，遍历一遍后栈中的字符就没有重复了，然后把栈中的字符全部弹出来，但此时顺序与原字符串是反的，需要再反转一下。

代码展示

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        char[] ch = s.toCharArray();
        for(char c : ch){
            if(stack.isEmpty() || stack.peek() != c){
                stack.push(c);
            }else{
                stack.pop();
            }
        }
        StringBuilder sb = new StringBuilder();
        while(!stack.isEmpty()){
            sb.append(stack.pop());
        }
        sb.reverse();
        return sb.toString();
    }
}

参考资料

代码随想录