题目来源于力扣（LeetCode）

目录

• 一、题目
• 二、解题思路
  • 2.1 双指针法
  • 2.2 双指针法-优化版
• 三、代码实现
  • 3.1 双指针法
  • 3.2 双指针法-优化版
• 四、执行用时
  • 4.1 双指针法
  • 4.2 双指针法-优化版
• 五、部分测试用例

一、题目

443. 压缩字符串

题目相关标签：字符串

注意：

1. 所有字符都有一个ASCII值在[35, 126]区间内。
2. 1 <= len(chars) <= 1000。

二、解题思路

2.1 双指针法

1. 题目分析： 在完成原地修改输入数组后，返回数组的新长度。 即方法中返回的 int 值是修改输入数组后，新的数组结束索引（该索引一定是小于等于原数组的结束索引）

2. 通过快慢指针的方式来遍历数组，快指针在前边遍历扫描数组元素，慢指针在后边记录修改数组的元素并记录索引

3. 从索引 1 开始遍历，判断当前遍历元素是否与前一元素相同，相同时，使记录出现次数的变量 count 加 1

4. 遍历元素与前一元素不同时，进行修改数组的操作，首先在慢指针的索引上赋值为前一不同的元素

5. 如出现次数大于 1 时，进行 “压缩” 的操作，即将出现次数的字符串形式以单字符的形式添加到数组中

6. 仍通过慢指针的索引来将出现次数的转换后的单个字符修改到数组中

2.2 双指针法-优化版

1. 在方法一的基础上逻辑不变，仅将元素出现次数的 count 值转换成字符串时直接遍历字符串，不转换成字符数组操作

   因为题目中注明了数组长度最大为 1000，且元素出现的次数大多数为一位数或两位数时，此时直接操作字符串要比转换成字符数组更快速

三、代码实现

3.1 双指针法

public static int compress(char[] chars) {
    int fast = 1;  // 快指针，用于扫描 chars 数组
    int slow = 0;  // 慢指针，用于记录插入新元素的索引位置
    int count = 1;  // 元素出现的次数

    while (fast < chars.length) {
        // 当前元素与前一元素相同时，出现次数加 1
        if (chars[fast] == chars[fast - 1]) {
            count ++;
        } else {
            // 元素不同时，通过慢指针，修改数组
            chars[slow++] = chars[fast - 1];
            // 次数大于 1 时，需要加上次数的字符形式
            if (count > 1) {
                char[] counts = ("" + count).toCharArray();
                for (char c : counts) {
                    chars[slow++] = c;
                }
                // 重置新元素的出现次数为 1
                count = 1;
            }
        }
        fast++;
    }
    // 操作数组末位的字符
    chars[slow++] = chars[fast - 1];
    if (count > 1) {
        // 次数大于 1 时，需要加上次数的字符形式
        char[] counts = ("" + count).toCharArray();
        for (char c : counts) {
            chars[slow++] = c;
        }
    }
    // 返回慢指针的索引，结束索引 + 1 = 数组长度 
    return slow;
}

3.2 双指针法-优化版

public static int compress(char[] chars) {
    int fast = 1;  // 快指针，用于扫描 chars 数组
    int slow = 0;  // 慢指针，用于记录插入新元素的索引位置
    int count = 1;  // 元素出现的次数

    while (fast < chars.length) {
        // 当前元素与前一元素相同时，出现次数加 1
        if (chars[fast] == chars[fast - 1]) {
            count ++;
        } else {
            // 元素不同时，通过慢指针，修改数组
            chars[slow++] = chars[fast - 1];
            // 次数大于 1 时，需要加上次数的字符形式
            if (count > 1) {
                // 因数组长度最大为 1000，所以直接操作字符串要比转换成字符数组更快速
                String countStr = String.valueOf(count);
                for (int i = 0; i < countStr.length(); i++) {
                    chars[slow++] = countStr.charAt(i);
                }
                // 重置新元素的出现次数为 1
                count = 1;
            }
        }
        fast++;
    }
    // 对于末位的字符进行的操作
    chars[slow++] = chars[fast - 1];
    if (count > 1) {
        String countStr = String.valueOf(count);
        for (int i = 0; i < countStr.length(); i++) {
            chars[slow++] = countStr.charAt(i);
        }
    }
    // 返回慢指针的索引，结束索引 + 1 = 数组长度
    return slow;
}

四、执行用时

4.1 双指针法

4.2 双指针法-优化版

五、部分测试用例

public static void main(String[] args) {
    char[] chars = {'a', 'a', 'b', 'b', 'c', 'c', 'c'};
    // output:6  change:{'a', '2', 'b', '2', 'c', '3', 'c'};
    
//    char[] chars = {'a'};
    // output:1  change:{'a'};
    
//    char[] chars = {'a', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b'};
    // output:6  change:{'a', 'b', '1', '2', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b'};
    
//    char[] chars = {'a', 'b', 'c'};
    // output:3  change:{'a', 'b', 'c'};
    
//    char[] chars = {'a', 'a', 'a', 'a', 'b', 'a'};
    // output:4  change:{'a', '4', 'b', 'a'};
    int result = compress(chars);
    System.out.println(result);
}