844. 比较含退格的字符串

栈

import java.util.Stack;

class Solution {
    public boolean backspaceCompare(String s, String t) {

        /**
         * 将字符串压入栈，遇到#则弹出
         */
        Stack<Character> stack1 = new Stack<>();
        Stack<Character> stack2 = new Stack<>();

        for (int i = 0; i < s.length(); i++) {

            char c = s.charAt(i);

            if (c != '#'){
                stack1.push(c);
            }
            else {

                if (!stack1.isEmpty()) {
                    stack1.pop();
                }
            }
        }

        for (int i = 0; i < t.length(); i++) {

            char c = t.charAt(i);

            if (c != '#'){
                stack2.push(c);
            }
            else {

                if (!stack2.isEmpty()) {
                    stack2.pop();
                }
            }
        }

        return stack1.toString().equals(stack2.toString());
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(n)
 */

优化1——双指针法减少空间消耗

class Solution {
    public boolean backspaceCompare(String s, String t) {

        /**
         * 双指针法，从后往前遍历字符串
         */
        int i = s.length() - 1;
        int j = t.length() - 1;

        /**
         * 记录字符串中#的次数，当遇到非#时，根据#的剩余次数决定跳过还是比较当前字符
         */
        int num_s = 0;
        int num_t = 0;

        while (i >= 0 || j >= 0) {

            /**
             * 分别找到两个字符串中第一个需要比较的字符，找到即终止内循环
             */
            while (i >= 0) {

                if (s.charAt(i) == '#') {

                    i--;
                    num_s++;
                } else {

                    if (num_s > 0) {

                        i--;
                        num_s--;
                    } else {
                        break;
                    }
                }
            }

            while (j >= 0) {

                if (t.charAt(j) == '#') {

                    j--;
                    num_t++;
                } else {

                    if (num_t > 0) {

                        j--;
                        num_t--;
                    } else {
                        break;
                    }
                }
            }

            /**
             * i和j必须同时大于0或者小于0，否则说明一个字符串遍历完了，另一个还有剩余字符
             * 同时大于0时，比较字符，如果相等就继续遍历
             * 同时小于0时会自动终止外循环
             */
            if (i >= 0 && j >= 0){

                if (s.charAt(i) != t.charAt(j)) {
                    return false;
                }

                i--;
                j--;
            }
            else if (i >= 0 || j >= 0){
                return false;
            }
        }

        return true;
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 */

https://leetcode-cn.com/problems/backspace-string-compare/