力扣 1047.删除字符串中的所有相邻重复项

问题描述

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

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

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

示例：

输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

提示：

1. 1 <= S.length <= 20000
2. S 仅由小写英文字母组成。

问题思路

思路1：蛮力法 + String

​ 首先采用蛮力法，定义变量 res 表示删除后的字符串，初始值为空。然后对原字符串进行一次扫描，当res为空或res中最后一个元素与当前正在扫描的元素不同时，在res后直接加上正在扫描的元素。否则将 res 的最后一个元素删除。

​ 实现代码如下，空间复杂度O(1)，时间复杂度O(n)。运行时间229 ms。

class Solution {
	public String removeDuplicates(String S) {
		int n = S.length();
		String res = "";
		for (int i = 0; i < n; i++) {
			if (res.length() == 0 ||(res.charAt(res.length()-1) != S.charAt(i))) {
				res += S.charAt(i);
			}else {
				res = res.substring(0,res.length()-1);
			}
		}
		return res;
	}
}

思路2：蛮力法 + 栈 + StringBuilder

​ 使用和思路1相同的方法，不同的实现方式。

​ 用栈来去除重复字符。对原字符串进行一次扫描，若当前元素与栈顶元素相同，将栈顶元素出栈；否则，将当前元素入栈。扫描完成后，依次出栈剩余元素，并用StringBuilder进行字符串构建，即为结果。

​ 实现代码如下，空间复杂度O(n)，时间复杂度O(n)。运行时间61 ms。

class Solution {
	public String removeDuplicates(String S) {
		int n = S.length();
		Stack<Character> stack = new Stack<Character>();
		StringBuilder res = new StringBuilder();
		stack.push(S.charAt(0));
		for (int i = 1; i < n; i++) {
			char c = S.charAt(i);
			if (stack.isEmpty() || stack.peek() != c) {
				stack.push(c);
			}else {
				stack.pop();
			}
		}
		while(!stack.isEmpty()) {
			res.insert(0, stack.pop());
		}
		return res.toString();
	}
}

思路3：蛮力法 + StringBuffer

​ 使用和思路1相同的方法，不同的实现方式。

​ 用StringBuffer来去除重复字符并保存新字符串，代替实现栈的功能。还是对原字符串进行一次扫描，若当前元素与栈顶元素相同，删除StringBuffer栈顶元素；否则，将当前元素入栈。扫描完成后，直接返回StringBuffer即可。

​ 实现代码如下，空间复杂度O(n)，时间复杂度O(n)。运行时间14 ms。

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

思路4：蛮力法 + 双数组

​ 使用和思路1相同的方法，不同的实现方式。

​ 定义char数组sArray保存原字符串。定义char数组res来去除重复字符并保存新字符串，代替实现栈的功能。还是对原字符串进行一次扫描，若当前元素与栈顶元素相同，删除res栈顶元素；否则，将当前元素入栈。扫描完成后，直接返回res的字符串形式即可即可。

​ 实现代码如下，空间复杂度O(n)，时间复杂度O(n)。运行时间4 ms。

class Solution {
    public String removeDuplicates(String S) {
    	int n = S.length();
        char[] sArray = S.toCharArray();
        char[] res = new char[n];
        int rTop = -1;
        for (char c : sArray) {
            if (rTop >= 0 && res[rTop] == c) {
                rTop--;
            } else {
                res[++rTop] = c;
            }
        }  
        return new String(res, 0, rTop + 1);
    }
} 

总结

​ 虽然四个思路使用的方法完全相同，但是采用了不同的实现方式，最后得到的执行时间却相差很大。对比可见，对于频繁插入删除的效率：数组 > StringBuffer > 栈 + StringBuilder > String.