栈与队列系列② -- 删除字符串中的所有相邻重复项

题目概述

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

题目：
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例：

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

解题思路

此题有两种方法：

• 双指针法
• 利用栈结构解题

方法一

若使用双指针法的话，其主要思想就是：遇到两个一样的，把他给覆盖掉！首先在创建快慢指针后，将字符串转化为char[]型数组，让快慢指针首先均指向数组的头部，当慢指针所指内容与其前一位的内容相同时，慢指针后退一位，然后将快指针的内容覆盖到慢指针上。（为什么不是慢指针所指内容与其后一位的内容相同时呢？如果这样的话当快指针覆盖过来的内容与慢指针的前一位也相同了，这种情况就处理不了了。）就这样直到快指针到数组的尾部。最后返回慢指针所指部分的前面即可。

方法二

若使用栈的结构做这道题的话，思路就是把字符串的每一个字符往栈中添加，每次添加的时候与栈顶的元素比较，如果一样的话就不加入并且把栈顶的元素给弹出来，如此下去。最后把栈中的字符拿出来拼接成字符串后，再reverse一下即可。

若直接将字符串作为栈，可以省去转化为字符串的操作

还有第三种将字符串转化为StringBuilder之后，向末尾添加一个空字符，将字符串的开头依次弹出，并于字符串的末尾比较，如果相同则把末尾的字符也弹出，如果不相同则把开头弹出的字符添加到字符串尾部，如此进行，直到第一个字符是开头添加的那个空字符。不过此法效率较低，不是很推荐使用。
如图：

代码实现

方法一

public class LeetCode1047ProMax {
    // 此方法使用双指针法
    public String removeDuplicates(String s) {
        //首先将String化为char型数组
        char[] ss = s.toCharArray();
        // 建立快慢指针
        int head = 0;
        int end = 0;
        while(end < ss.length){
            ss[head] = ss[end];
            if(head > 0 && ss[head] == ss [head-1]){
                head--;
            }else{
                head++;
            }
            end++;
        }
        return new String(ss).substring(0,head);
    }
}

方法二（第一种）

ArrayDeque<Character> deque = new ArrayDeque<>();
        char ch;
        for (int i = 0; i < S.length(); i++) {
            ch = S.charAt(i);
            if (deque.isEmpty() || deque.peek() != ch) {
                deque.push(ch);
            } else {
                deque.pop();
            }
        }
        String str = "";
        //剩余的元素即为不重复的元素
        while (!deque.isEmpty()) {
            str = deque.pop() + str;
        }
        return str;

方法二（第二种）

public String removeDuplicates(String s) {
        // 将 res 当做栈
        StringBuffer res = new StringBuffer();
        // top为 res 的长度
        int top = -1;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            // 当 top > 0,即栈中有字符时，当前字符如果和栈中字符相等，弹出栈顶字符，同时 top--
            if (top >= 0 && res.charAt(top) == c) {
                res.deleteCharAt(top);
                top--;
            // 否则，将该字符 入栈，同时top++
            } else {
                res.append(c);
                top++;
            }
        }
        return res.toString();
    }

方法三（第三种）

public String removeDuplicates(String s) {
        StringBuilder ss = new StringBuilder(s);
        ss.append(' ');
        while(ss.charAt(0) != ' '){
            char head = ss.charAt(0);
            ss.deleteCharAt(0);
            if(ss.charAt(ss.length() - 1) == head){
                ss.deleteCharAt(ss.length() - 1);
            }else{
                ss.append(head);
            }
        }
        ss.deleteCharAt(0);
        return new String(ss);
    }

做题反思

第一次做这道题的时候我想的使用双指针法，不过超时，代码如下：

// 尝试用双指针
    public String removeDuplicates(String s) {
        if (s.length() < 2) {
            return s;
        }
        StringBuilder ss = new StringBuilder(s);
        // 创建双指针
        // 前指针
        int head = 0;
        int end = 1;
        while (end < ss.length()) {
            if (ss.charAt(head) == ss.charAt(end)) {
                ss.delete(head, end + 1);
                head = 0;
                end = 1;
                continue;
            }
            head++;
            end++;
        }
        if (ss.length() < 2) {
            return new String(ss);
        } else if (ss.charAt(0) == ss.charAt(1)) {
            return "";
        }
        return new String(ss);
    }

结果超时了，因为测验项中有一个超长的字符串，所以此题如果时间复杂度是O(n2)的话极大的机率是不会通过的。这一段代码乍一看时间复杂度是O(n)但是如果了解StringBuilder的底层实现原理的话，可以很容易的知道这个delete操作它的时间复杂度就已经是O(n)了，再于while嵌套，肯定是会超时的。

• 对双指针法掌握的不透彻
• 对数据的底层结构加强探索