LeetCode——844 比较含退格的字符串(java)

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

1. 用“栈”解决，用StringBuilder模拟栈，底层是char数组

StringBuilder是可变对象，用来高效拼接字符串；

StringBuilder可以支持链式操作，实现链式操作的关键是返回实例本身；

StringBuffer是StringBuilder的线程安全版本，现在很少使用。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        String resultS = result(s);
        String resultT = result(t);
        if(resultS.equals(resultT)){
            return true;
        }else{
            return false;
        }
        
    }

    public String result(String str){
        //1.使用StringBuilder模拟栈
        StringBuilder builder = new StringBuilder();
        int length = str.length();
        for(int i = 0; i < length; ++i){
            char c = str.charAt(i);
            if(c != '#'){
                builder.append(c);
            }else if(builder.length() > 0){
                //builder还没删空，且c为#，那么就删掉前一个
                builder.deleteCharAt(builder.length() - 1);
            }
            //都不匹配的场景就是c为#，但是builder已经删空了，略过

        }
        return builder.toString();

    }
}

2.用双指针解决

class Solution {
    public boolean backspaceCompare(String S, String T) {
        //两个指针，从尾部开始
        int sp = S.length() - 1, tp = T.length() - 1;
        //当前未消耗的#个数
        int delS = 0, delT = 0;
        while(sp >= 0 || tp >= 0){

            while(sp >= 0){
                char c = S.charAt(sp);
                //遇到#：未消耗的#加一
                if(c == '#'){
                    ++delS;
                    --sp;
                }
                //遇到正常字符：消耗#
                else{
                    if(delS > 0){
                        --delS;
                        --sp;
                    }
                    //没有可以消耗的#：字符需要保留
                    else{
                        break;
                    }
                }
            }

            while(tp >= 0){
                char c = T.charAt(tp);
                //遇到#：未消耗的#加一
                if(c == '#'){
                    ++delT;
                    --tp;
                }
                //遇到正常字符：消耗#
                else{
                    if(delT > 0){
                        --delT;
                        --tp;
                    }
                    //没有可以消耗的#：字符需要保留
                    else{
                        break;
                    }
                }
            }
            
            //两个字符串都没到头：比较留下的两个字符
            if((sp >= 0) && (tp >= 0)){
                //当前字符不相同或者其中有一个到头了就返回false；反之当前字符相等或者两个都到头了，就继续判断
                if(S.charAt(sp) != T.charAt(tp)){
                    return false;
                }
            }
            else if((sp >= 0) || (tp >= 0)){
                return false;
            }
            //注意写法，这里不能加else，加了的话就只是两个都到头了这一种情况了，那么两个头没到头切字符相同的大括号里应该也加上下面两句
            --sp;
            --tp;

        }
        return true;
    }
}

分析情况：

通过内层的while循环找到每个字符串确定输出的最后一个字符，这是不管前面的先进行判断：

如果两个字符串都没到头，那么看这最后一个字符是否相等

如果不想等，则结果为false

如果相等，则还需要继续向前判断

如果两个字符串中有一个到头了，那么返回false，因为另一个确定有输出

如果两个字符串的指针同时为-1，即同时到头，则返回true

这对应着两种情况，即两个字符串的结果都为“”或每一次比较后输出的值都相同