[LeetCode]1089. Duplicate Zeros

Given a fixed length array arr of integers, duplicate each occurrence of zero, shifting the remaining elements to the right.

Note that elements beyond the length of the original array are not written.

Do the above modifications to the input array in place, do not return anything from your function.

Example 1:

Input: [1,0,2,3,0,4,5,0]
Output: null
Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]

Example 2:

Input: [1,2,3]
Output: null
Explanation: After calling your function, the input array is modified to: [1,2,3]

Note:

1 <= arr.length <= 10000
0 <= arr[i] <= 9

Solution:

这题目的大概意思是让你遍历数组，如果遇到0就往0后面再添加一个0，之后的元素向右平移，超过数据长度的元素会被舍弃。
这里说只能原地修改数组，这句话有两种解释。第一个解释是不能使用额外的空间，第二个解释是不能返回新的数组(方法返回类型是void)。

解法一：队列标记替换

最直观的解法是，我们用一个队列保存需要平移的元素，然后遍历数组。如果队列不为空就用队列里最后加入的元素替换当前元素，如果遇到了0就把0加入到队列。

class Solution {
    public void duplicateZeros(int[] arr) {
      LinkedList<Integer> queue=new LinkedList<>();
        for(int i=0;i<arr.length;i++){
              if(0==arr[i]){
                queue.add(arr[i]);
            }
              if(queue.size()>0){
                 queue.add(arr[i]);
                  arr[i]=queue.poll();
            }
        }
    }
}

该解法性能如下：

执行用时 : 4 ms, 在所有 Java 提交中击败了57.21%的用户
内存消耗 :37.4 MB, 在所有 Java 提交中击败了100.00%的用户

解法二：双指针

双指针也许是本题的最优解法。具体思路是维护一个快指针和一个慢指针。快指针是遇到0就多进一步。这样遍历一遍数据后，快指针和慢指针会有一个差值。这个差值就是需要填充0的个数。

接下来，我们需要从后向前遍历数组。如果慢指针指向的元素不为0，则把快指针指向的元素替换为慢指针指向的元素；如果慢指针指向的元素为0，则把快指针和快指针之前指向的元素替换为0。

你可能会发现对于不同的数组，第一遍遍历之后fast指针的值是不一样的。区别在于数组末尾是否为0，如果末尾为0，则fast指针的值(数组索引)为数组长度+1。如果末尾不是0，则fast指针的值是数组长度。其实数组最后一位是0的话，其实是不用复制这个值的。因此从后向前遍历的时候需要判断fast指针的值是否小于n，这样就可以把数组末尾为0的时候就不会复制了。

class Solution {
    public void duplicateZeros(int[] arr) {
        int slow = 0;
        int fast = 0;
        int n = arr.length;
        while (fast < n) {
            if (arr[slow] == 0) {
                fast++;
            }
            fast++;
            slow++;
        }
        fast--;
        slow--;
        while (slow >= 0) {
            if (fast < n) {
                arr[fast] = arr[slow];
            }
            if (arr[slow] == 0) {
                arr[--fast] = arr[slow];
            }
            fast--;
            slow--;
        }
    }
}

该解法性能如下：

执行用时 : 1 ms, 在所有 Java 提交中击败了99.87%的用户
内存消耗 :37.1 MB, 在所有 Java 提交中击败了100.00%的用户