[Java 算法] 栈 - 技术栈

练习 1 : 删除字符串中所有相邻重复项

java 复制代码

class Solution {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        int n = s.length();
        if(n<=1){
            return s;
        }
        stack.push(s.charAt(0));
        for(int i = 1;i<n;i++){
            if(!stack.isEmpty()&&s.charAt(i) == stack.peek()){
                stack.pop();
            }else{
                stack.push(s.charAt(i));
            }
        }      
        StringBuffer ret = new StringBuffer();  
        while(!stack.isEmpty()){
            ret.append(stack.pop());
        }
        ret.reverse();
        return ret.toString();
    }
}

算法原理 : 使用普通栈结构

用栈保存当前合法字符
遍历每个字符：

- 栈不空 且当前字符 = 栈顶 → 说明相邻重复，栈顶出栈
- 否则 当前字符入栈

最后栈中就是去重后的结果，逆序输出

练习二 : 比较含退格的字符串

844. 比较含退格的字符串 - 力扣（LeetCode）

java 复制代码

class Solution {
    public boolean backspaceCompare(String s, String t) {
        return changeStr(s).equals(changeStr(t));
    }
    public String changeStr(String s){
        StringBuffer ret = new StringBuffer();//模拟栈结构
        for(int i =0;i<s.length();i++){
            char ch = s.charAt(i);
            if(ch != '#') ret.append(ch);//入栈
            if(ch == '#'&&ret.length()>0) ret.deleteCharAt(ret.length()-1);//出栈
        }
        return ret.toString();
    }
}

算法原理 : 用字符串模拟栈结构

用 StringBuffer模拟栈
遍历字符：

- 不是 # → 入栈
- 是 # 且栈不空 → 删除最后一个字符（退格）

分别处理 s 和 t，得到最终字符串再比较

练习三 : 基本计算器 2

227. 基本计算器 II - 力扣（LeetCode）

java 复制代码

class Solution {
    public int calculate(String s) {
        Stack<Integer> stack = new Stack<>();
        int i = 0;
        char[] ch = s.toCharArray();
        char op = '+';
        while(i<s.length()){
            char tmp = ch[i];
            if(tmp == '+'||tmp == '-'||tmp == '*'||tmp =='/') op = ch[i++];
            else if(ch[i]>='0'&&ch[i]<='9'){
                int a = 0;
                while(i<ch.length&&ch[i]>='0'&&ch[i]<='9'){
                    int b = ch[i++]-'0';
                    a = a*10+b;
                }
                switch(op){
                    case '+': 
                        stack.push(a);
                        break;
                    case '-':
                        stack.push(-a);
                        break;
                    case '*':
                        stack.push(stack.pop()*a);
                        break;
                    case '/':
                        stack.push(stack.pop()/a);
                        break;
                }

            }else{
                tmp = ' ';
                i++;
            }
        }
        int ret = 0;
        while(!stack.isEmpty()){
            ret+=stack.pop();
        }
        return ret;
    }
}

算法原理 : 模拟

练习四 : 验证栈序列

946. 验证栈序列 - 力扣（LeetCode）

java 复制代码

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        Stack<Integer> st = new Stack<>();
        int i = 0,n = popped.length;
        for(int x: pushed){
            st.push(x);
            while(!st.isEmpty()&&st.peek() == popped[i]){
                st.pop();
                i++;
            }
        }
        return i == n;
    }
}

算法原理 : 模拟

按 pushed 顺序依次入栈
每入栈一个，就检查：

- 栈顶 == popped[i]
- 满足就一直出栈，i 后移

最后 i == 弹出数组长度 → 合法