【Java】比较含退格的字符串

一开始想到用栈存储字符串，也想过用指针，但不知道从前往后如何比较。后面尝试用双指针从后往前遍历。

1.栈方法解决

class Solution {
    public boolean backspaceCompare(String s, String t) {
        //栈解决
        ArrayStack stack = new ArrayStack(s.length());
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)!='#'){
                stack.push(s.charAt(i));
            }
            // else if(s.charAt(i)=='#' && stack.isEmpty()!=true){
            else if(s.charAt(i)=='#' && stack.size()>0){

                stack.remove();
            }
        }
        ArrayStack stackT = new ArrayStack(t.length());
        for(int i=0;i<t.length();i++){
            if(t.charAt(i)!='#'){
                stackT.push(t.charAt(i));
            }
            // else if(t.charAt(i)=='#' && stackT.isEmpty()!=true){
            else if(t.charAt(i)=='#' && stackT.size()>0){

                stackT.remove();
            }
        }
        if(stack.size()!=stackT.size()) return false;


        //remove后size会变小 因此无法全部遍历
        // for(int i=0;i<stack.size();i++){
        //     if(stack.remove()!=stackT.remove())return false;
        // }
         while (!stack.isEmpty()) {
            if (stack.remove() != stackT.remove()) {
                return false;
            }
        }

        return true;
    }
}

class ArrayStack{
    private int maxSize;//栈大小
    private int top;//栈顶
    private char[] stack;//存放栈数据

    //方法为 push、remove、isEmpty、isFull、size、peak
    //构造函数
    ArrayStack(int maxSize){

        this.maxSize = maxSize;
        this.top = -1;
        this.stack = new char[maxSize];
    }
    public void push(char c) {
        // if(isFull())throw new Exception("栈满");
        top++;
        stack[top] = c;
    }
    public int remove() {
        // if(isEmpty())throw new Exception("栈空");
        top--;
        return stack[top+1];
    }
    public boolean isEmpty(){
        return top==-1;
    }
    public boolean isFull(){
        return top+1==maxSize;
    }
    public int size(){
        return top+1;
    }
}

AC了但内存占用比较大

2.双指针法解决

每个字符串都有一个遍历当前位置的指针i和j，以及存储当前需退格的长度sBack和tBack。以字符串s为例，首先从后往前判断有无需要退格的字符，遇到#则sBack++，指针往前一个继续判断前一位是否需要退格，直至当前非#；然后通过i–跳过当前需退格的字符。直至无需退格的的位置（即i指向）。再与字符串t当前指针j指向的位置进行比较，若字符不同则返回false，若i和j有任意一个指向-1，继续判断i和j是否都指向-1，若有一个还指向字符则说明两者长度不一致，返回false。

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

        //双指针解决
        int sLength = s.length();
        int tLength = t.length();
        int sBack = 0,tBack =0;//双指针记录#的当前个数 ij记录当前比较字符位置
        for(int i=sLength-1,j=tLength-1;i>=0||j>=0;i--,j--){
            //先判断s和t是否需要跳过字符 然后再进行字符比较
            
            while(i>=0){
                if(s.charAt(i) =='#'){
                    sBack++;
                    i--;
                }
                else if(sBack>0){
                    sBack--;
                    i--;
                }
                else{
                    break;//循环退格 不退格则退出
                }
            }
            while(j>=0){
                if(t.charAt(j) =='#'){
                    tBack++;
                    j--;
                }
                else if(tBack>0){
                    tBack--;
                    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;
                }
            }

        }
        return true;
    }
}

可能是变量开太多了内存占用比较大