LeetCode刷题（数组）：移动零 与 找到所有数组中消失的数字

1.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例一：
示例二：

1.双指针求解

面对此问题，我们可以定义两个指针变量$i,j,i$的初值为0，j也负责从0开始遍历数组元素，如果$nums[j]!=0$,则令$nums[i]=nums[j]$,同时$i$++,$j$++，当$j$遍历完数组最后一个元素后，直接将数组i索引$i$-$j$之间的元素全部赋值为0即可求解该问题。

class Solution {
    public void moveZeroes(int[] nums) {
        //定义双指针
        int i=0;
        int j=0;
        for(;j<nums.length;j++){
            if(nums[j]!=0){
                nums[i]=nums[j];
                i++;
            }
        }
        while(i<j){
            nums[i]=0;
            i++;
        }
    }
}

2.双指针GIF动图演示

GIF动图演示如下所示，a,b即为上述所所的双指针遍历，具体变化情况如下所示：

3.时间复杂度分析

由于本次算法实现中，遍历$i,j$分别遍历了整个数组元素,因此总算法的时间复杂度就为$O(2n)$，根据时间复杂度的定义，即为$O(n)$,算法在LeetCode的执行结果如下所示：

2.找到所有数组中消失的数字

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
示例一：

示例二：

进阶：你能在不使用额外空间且时间复杂度为 O(n) 的情况下解决这个问题吗? 你可以假定返回的数组不算在额外空间内。

1.使用集合遍历

这里需要额外定义两个ArrayList集合，一个集合list用来存储nums出现的所有不重复的元素，一个集合result作为结果集返回，一次遍历完nums数组后，list集合中填充则不重复的元素，最后从$1-n$开始遍历，一次判断当前元素$i$是否在当前list集合中，如果不在，则add到result集合中；遍历结束后将result结果返回即可！

class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {
        List<Integer> list=new ArrayList<>();
        List<Integer> result=new ArrayList<>();
        for(int i=0;i<nums.length;i++){
            if(!list.contains(nums[i])){
                list.add(nums[i]);
            }
        }
        for(int i=1;i<=nums.length;i++){
            if(!list.contains(i))
            result.add(i);
        }
        return result;
    }
}

2.时间复杂度分析

本次算法的实现过程中有两次循环遍历，一次循环是为了筛选nums数组中不重复的元素并填充之list集合中，另一次循环是依次判断元素$1-n$是否在list集合中，因此总的时间复杂度为$O(2n)$，即$O(n)$。
但是，将这段代码放入LeetCode中执行，则会返现LeetCode会显示超出时间限制，不允许通过！具体如下所示：

因此，我们还得想时间复杂度更低的算法。

3.原数组操作

由于方法一另外开辟了一个临时集合，增大了空间复杂度，因此我们这次救灾原数组上进行一系列的操作！
首先，我们依次遍历数组，对于数组元素$nums[i]$，对它进行减1并取模。最后的结果为k，再对$nums[k]+n$，使得$nums[k]$的值大于$n$，因为如果将元素从小到大排序，值为$k$的元素，应该在$k-1$的索引位置上。 对数组中的每一个元素都按照此操作。
最后，重新对数组$nums$进行遍历，如果发现$nums[i]<=n$，即表示$i+1$的值在数组中不存在，将其添加值集合中即可。

class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {
       int n=nums.length;
       List<Integer> result=new ArrayList<>();
       for(int i=0;i<n;i++){
           int k=(nums[i]-1)%n;
           nums[k]+=n;
       }
       for(int i=0;i<n;i++){
           if(nums[i]<=n){
               result.add(i+1);
           }
       }
       return result;
    }
}

4.演示过程展示

如果上述的代码原理并未理解清晰，可以看一个算法的演示过程，具体如下所示：
这里的演示采用的是对nums[k]取相反数，代码中给出的是对nums[k]+n的解法，二者实际上是大同小异，但是如果想实现取相反数的操作，需要判断当前元素的正负，再次遍历到的时候还需要对元素进行还原，过程可能稍微复杂。有兴趣的小伙伴 可以自行调试！

5.时间复杂度分析

此时同样是两次循环遍历，但不同的是，这一次我们并未开辟新的集合空间，就是在原数组中进行操作的，极大的减少了算法的空间复杂度，代码在LeetCode中的执行情况如下所示：