2460. 对数组执行操作

题目

给你一个下标从 0 开始的数组 nums ，数组大小为 n ，且由 非负 整数组成。

你需要对数组执行 n - 1 步操作，其中第 i 步操作（从 0 开始计数）要求对 nums 中第 i 个元素执行下述指令：

• 如果 nums[i] == nums[i + 1] ，则 nums[i] 的值变成原来的 2 倍，nums[i + 1] 的值变成 0 。否则，跳过这步操作。

在执行完 全部 操作后，将所有 0 移动 到数组的 末尾 。

• 例如，数组 [1,0,2,0,0,1] 将所有 0 移动到末尾后变为 [1,2,1,0,0,0] 。

返回结果数组。

注意 操作应当 依次有序 执行，而不是一次性全部执行。

示例 1：

输入：nums = [1,2,2,1,1,0]
输出：[1,4,2,0,0,0]
解释：执行以下操作：
- i = 0: nums[0] 和 nums[1] 不相等，跳过这步操作。
- i = 1: nums[1] 和 nums[2] 相等，nums[1] 的值变成原来的 2 倍，nums[2] 的值变成 0 。数组变成 [1,4,0,1,1,0] 。
- i = 2: nums[2] 和 nums[3] 不相等，所以跳过这步操作。
- i = 3: nums[3] 和 nums[4] 相等，nums[3] 的值变成原来的 2 倍，nums[4] 的值变成 0 。数组变成 [1,4,0,2,0,0] 。
- i = 4: nums[4] 和 nums[5] 相等，nums[4] 的值变成原来的 2 倍，nums[5] 的值变成 0 。数组变成 [1,4,0,2,0,0] 。
执行完所有操作后，将 0 全部移动到数组末尾，得到结果数组 [1,4,2,0,0,0] 。

示例 2：

输入：nums = [0,1]
输出：[1,0]
解释：无法执行任何操作，只需要将 0 移动到末尾。

提示：

• 2 <= nums.length <= 2000
• 0 <= nums[i] <= 1000

思路

题目的第一步其实只是模拟，所以按照题意写一遍代码就行，真正的部分在后面的排序，把所有0拍到后面去，并且保持稳定性，也就是原本的字符顺序不能变。

所以这里第一次我没有读懂题意，直接把所有0跟后面的字符替换，这样自然破坏了稳定性，导致用例没有通过。

class Solution {
    public int[] applyOperations(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                nums[i] = 2 * nums[i];
                nums[i + 1] = 0;
            }
        }
        // 移动零
        int i = 0, j = nums.length - 1;
        while (i < j) {
            // 找到末尾第一个不为0的位置
            while (nums[j] == 0 && i < j) {
                j--;
            }
            if (nums[i] == 0) {
                int swap = nums[i];
                nums[i]=nums[j];
                nums[j]=swap;
            }
            i++;
        }
        return nums;
    }
}

之后我们换一种思路，用一个新数组存放所有非零元素，之后再补齐0，（其实补齐0根本没必要，数组初始不就是0吗）

public int[] applyOperations(int[] nums) {
    for (int i = 0; i < nums.length - 1; i++) {
        if (nums[i] == nums[i + 1]) {
            nums[i] = 2 * nums[i];
            nums[i + 1] = 0;
        }
    }
    // 移动零 创建一个新数组，先把所有不为0元素移动到新数组中，再补0
    int[] newArr = new int[nums.length];
    int index = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] != 0) {
            newArr[index++] = nums[i];
        }
    }
    return newArr;
}

但是这里用到了新的存储空间，不够优雅，还能再优化吗？

当然可以了，两个思路：

1. 原地更换
2. 第一段模拟的代码中，如果当前的元素为0，就跳过。

为什么？

因为当i=0时，我们有两种情况：

一是下一位为0，我们执行的操作是把2*0=0赋值到i位置，下一位赋值0，其实没动。
二是下一位不为0，我们不执行操作，也没动。

所以综上，直接跳过即可。

用一个j记录当前不为0的位置，每当遇到一个不为0的元素，直接赋值到该位置，至于j后面的元素，反正以后都是0直接覆盖就行。

public int[] applyOperations(int[] nums) {
    int j = 0;
    for (int i = 0; i < nums.length - 1; i++) {
        if (nums[i] == 0) continue;
        if (nums[i] == nums[i + 1]) {
            nums[i] = 2 * nums[i];
            nums[i + 1] = 0;
        }
        // j记录当前不为0的元素
        if (nums[i] != 0) {
            nums[j] = nums[i];
            j++;
        }
    }
    // 由于遍历只到n-1，所以要把最后一项也搬进去
    if (nums[nums.length - 1] != 0) {
        nums[j] = nums[nums.length - 1];
        j++;
    }
    for (int i = j; i < nums.length; i++) {
        nums[i] = 0;
    }
    return nums;
}