回退字符串

遇到#就后退一个字符串

“a##c” =="#a#c"
“y#fo##f” ==“y#f#o##f”
"#c"意思是这种情况就是生成 c

利用栈

 /**
     * 利用栈操作 开辟了额外的空间
     * @param S
     * @param T
     * @return
     */
    public boolean backspaceCompare(String S, String T) {
           return newStr(S).equals(newStr(T));
    }
    private String newStr(String S){
        Deque<Character> stack=new LinkedList<>();
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < S.length(); i++) {
            if (S.charAt(i)>='a'&&S.charAt(i)<='z'){
                //是数字就入栈
                stack.push(S.charAt(i));
                continue;
            }
            //是#就弹出栈
            if (!stack.isEmpty()) stack.pop();
        }
        while (!stack.isEmpty()){
            sb.append(stack.pop());
        }

        return sb.reverse().toString();
    }

双指针

 /**
     * 使用双指针
     * 从后往前遍历 因为删除的是#前面的数据
     * 每遍历到一个# 设置待删除的数的数量+1,每遇到一个数字，就让它减一
     * 空间复杂度o(1)
     */
    public boolean backspaceCompare2(String S, String T){
         int i=S.length()-1,j=T.length()-1;
         int skipS=0,skipT=0;
         while (i>=0||j>=0){
             while (i>=0){
                 if (S.charAt(i)=='#'){
                     skipS++;
                     i--;
                 }else if(skipS>0){
                      skipS--;
                      i--;
                 }else {
                     //上面两个条件都不满足
                     break;  //说明这个数不该删除
                 }
             }
             while (j>=0){
                 if (T.charAt(j)=='#'){
                     skipT++;
                     j--;
                 }else if(skipT>0){
                      skipT--;
                      j--;
                 }else {
                     break;
                 }
             }
             if (i>=0&&j>=0){
                 if (S.charAt(i)!=T.charAt(j)){
                     return false;
                 }
             }else if (i>=0||j>=0){
                 return false;
             }
             i--;
             j--;
         }
         return true;
    }