算法训练（leetcode）二刷第九天 | 232. 用栈实现队列、225. 用队列实现栈、20. 有效的括号、1047. 删除字符串中的所有相邻重复项

刷题记录

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

232. 用栈实现队列

栈与队列的存储顺序相反，因此用两个栈来实现队列。

时间复杂度： pop、peek是 O ( n ) O(n) O(n)，push、empty是 O ( 1 ) O(1) O(1)
空间复杂度： O ( n ) O(n) O(n)

java 复制代码

// java

class MyQueue {

    Stack<Integer> stIn;
    Stack<Integer> stOut;


    public MyQueue() {
        stIn = new Stack<>();
        stOut = new Stack<>();
    }
    
    public void push(int x) {
        stIn.push(x);
    }
    
    public int pop() {
        int x;
        x = peek();
        stOut.pop();
        return x;
    }
    
    public int peek() {
        int x;
        if(stOut.isEmpty()){
            while(!stIn.isEmpty()){
                x = stIn.peek();
                stOut.push(x);
                stIn.pop();
            }
        }
        return stOut.peek();
    }
    
    public boolean empty() {
        return (stOut.isEmpty() && stIn.isEmpty());
    }
}

/**
 * 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. 用队列实现栈

leetcode题目地址

同上题，两个队列实现栈。

略有不同之处是：取栈顶操作。需要先将quIn中的n-1个元素移出，剩余的一个元素即为栈顶。

**Tricks：**因为队列的先入先出特点，导致两个队列中的顺序是一致的，因此将元素始终存储在一个队列中，在移动过后交换两者的地址即可，无需再进行一次移动。

时间复杂度： O ( n ) O(n) O(n)
空间复杂度： O ( n ) O(n) O(n)

java 复制代码

// java
class MyStack {
    Queue<Integer> quIn;
    Queue<Integer> quOut;


    public MyStack() {
        quIn = new LinkedList<>();
        quOut = new LinkedList<>();
    }
    
    public void push(int x) {
        quIn.add(x);
    }
    
    public int pop() {
        int size = quIn.size()-1;
        while(size-->0){
            quOut.offer(quIn.poll());
        }
        int x = quIn.poll();
        // trick
        Queue<Integer> tmp = quOut;
        quOut = quIn;
        quIn = tmp;
        return x;
    }
    
    public int top() {
        int size = quIn.size()-1;
        while(size-->0){
            quOut.offer(quIn.poll());
        }
        int x = quIn.poll();
        quOut.offer(x);
        // trick
        Queue<Integer> tmp = quOut;
        quOut = quIn;
        quIn = tmp;
        return x;
    }
    
    public boolean empty() {
        return quIn.isEmpty();
    }
}

/**
 * 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. 有效的括号

leetcode题目地址

左括号入栈，右括号进行匹配，失配返回false。最终栈非空返回false，为空则意味着匹配成功返回true。

时间复杂度： O ( n ) O(n) O(n)
空间复杂度： O ( n ) O(n) O(n)

java 复制代码

// java
class Solution {
    public boolean isValid(String s) {
        Stack<Character> st = new Stack<>();
        boolean flag = true;
        for(int i=0; i<s.length(); i++){
            if(s.charAt(i)=='(' || s.charAt(i)=='[' || s.charAt(i)=='{'){
                st.push(s.charAt(i));
            }else{

                if(!st.isEmpty() && s.charAt(i)==')' && st.peek() == '(') st.pop();
                else if(!st.isEmpty() && s.charAt(i)==']' && st.peek() == '[') st.pop();
                else if(!st.isEmpty() && s.charAt(i)=='}' && st.peek() == '{') st.pop();
                else return false;
            }
        }
        return st.isEmpty();
    }
}

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

leetcode题目地址

借助栈，删除相邻的重复项。返回剩余字符时栈内弹出顺序是逆序，因此需要进行反转。

时间复杂度： O ( n ) O(n) O(n)
空间复杂度： O ( n ) O(n) O(n)

java 复制代码

// java
class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> st = new Stack<>();
        for(int i=0; i<s.length(); i++){
            char ch = s.charAt(i);
            if(!st.isEmpty() && st.peek() == ch){
                st.pop();
            }else{
                st.push(ch);
            }
        }
        StringBuilder sb = new StringBuilder();
        while(!st.isEmpty()){
            sb.append(st.pop());
        }
        return sb.reverse().toString();
    }
}