删除字符串中的所有相邻重复项 （动态规划，栈，数组模拟）

题目

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string

解

解法一、动态规划

f[i]表示i这个字符是否被删除,1代表已删除，初始化全部为0;

1. S[i]==S[i+1]时，f[i]与f[i+1] 都为1；
2. 否则，S[i]==S[j] (S[j]时在i最后一个未被删除字符)时，f[i]与f[j] 都为1；

class Solution {
   public String removeDuplicates(String S) {
        StringBuilder sb = new StringBuilder();
        int i = 1,n = S.length(),preOf0 = 0;
        if(n<=1) return S;
        int[] f = new int[n]; //0代表未删除，1代表删除
        Arrays.fill(f, 0);
        
        while(i<n)
        {
        	if(S.charAt(i-1)==S.charAt(i)&&f[i-1]!=1) {  //相邻直接删除 			
        		f[i] = 1;
        		f[i-1] = 1;
        	}else
        	{  //不直接相邻，看中间是否全删除
        		int j = i-1;
        		while(j>=0&&f[j]==1) j--;  //找上一个未被删除
        		if(j>=0&&S.charAt(j) == S.charAt(i))
        		{
        			f[i] = 1;
            		f[j] = 1; 
        		}
        	}
        	i++;
        }
        for(int k = 0; k < n; ++k)
        	if(f[k]==0)sb.append(S.charAt(k));
        return sb.toString();
    
}
}

时间复杂度：$O(n^2)$
空间复杂度：$O(n)$

解法二、栈

因为只将相邻的删除，字符要入栈刚好可以与相邻的字符作比较。整个字符串的字符都进入栈模拟一遍就ok了。

class Solution {
   public String removeDuplicates(String S) {
      
        int i = 1,n = S.length(),preOf0 = 0;
        if(n<=1) return S;
        Stack<Character> stack = new Stack<Character>();
        stack.push(S.charAt(0));
        while(i< n)
        {
        	char temp = S.charAt(i++);
        	if(!stack.empty()&&stack.peek()==temp)
        	{
        		stack.pop();
        	}
        	else
        		stack.push(temp);
        	  
        }
        char[] cs = new char[stack.size()];
       
        for(int k = stack.size()-1; k>=0; --k) cs[k]=stack.pop(); 
        return new String(cs);
    
}
}

时间复杂度：$O(n)$
空间复杂度：$O(n)$

解法三、用StringBuff模拟栈

class Solution {
    public String removeDuplicates(String S) {
        StringBuffer stack = new StringBuffer();
        int top = -1;
        for (int i = 0; i < S.length(); ++i) {
            char ch = S.charAt(i);
            if (top >= 0 && stack.charAt(top) == ch) {
                stack.deleteCharAt(top);
                --top;
            } else {
                stack.append(ch);
                ++top;
            }
        }
        return stack.toString();
    }
}
 

时间复杂度：$O(n)$
空间复杂度：$O(n)$

最快的-用数组模拟栈

class Solution {
    public String removeDuplicates(String S) {
        int n = S.length(); 
		
		char[] cs = new char[n];
		int top = 0;
		cs[top] =  S.charAt(0);
		int i  = 1;
		while(i< n)
		{
			char temp = S.charAt(i);
			if(top==-1||temp!=cs[top])  cs[++top] = temp;
			else top--;
			++i;
		}
		return new String(cs,0,top+1);
    }
}
 

时间复杂度：$O(n)$
空间复杂度：$O(n)$