题解记录~

最长连续序列

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1：

输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

示例 2：

输入：nums = [0,3,7,2,5,8,4,6,0,1]
输出：9

提示：

• 0 <= nums.length <= 10^5
• -10^9 <= nums[i] <= 10^9

思路

根据题意，给我们一个未排序的整数数组，要求找到该整数数组中最长的连续序列。所谓连续序列，就是形如1、2、3、4、5……的序列，序列中任意两个相邻的数字相差1。

对于这个问题我们要给出一个O(n)的解决方法，自然而然想到先对给定的数组进行排序，然后用双指针的方法，令两个指针分别指向前后两个相邻元素，遍历一遍这个数组。若遍历到的两个相邻元素相差1，那么答案就加1，否则判断当前遍历到的两个相邻元素是相等还是相差超过1，若相等，则直接将两个指针往后移，不用将当前答案归零，否则就需要先将答案归零，再将两个指针向后移。

需要注意特判一下空数组的情况，具体代码如下：

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        if (nums.size() == 0) return 0; // 特判空数组
        int ans = 1; // 记录最终答案
        int tmp = 1; // 记录当前答案
        sort(nums.begin(), nums.end());

        int i = 0, j = i + 1; // 双指针
        while (j < nums.size()) { // 遍历数组
            // 若相差1，则当前答案++，指针往后移
            if (nums[j] - nums[i] == 1) {
                tmp++;
                i = j++;
            } else { // 若相差不为1，则需要判断是相等还是相差超过1
                // 先更新答案，再判断要不要将当前tmp归零
                if (tmp > ans) ans = tmp;
                // 若相等，则只用把两个指针往后挪
                if (nums[j] == nums[i]) {
                    i = j++;
                    continue;
                }
                // 否则将tmp归零，再将指针往后挪
                tmp = 1;
                i = j++;
            }
        }
        // 最后再更新一次答案
        if (tmp > ans) ans = tmp;
        return ans;
    }
};

移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

提示:

• 1 <= nums.length <= 10^4
• -2^31 <= nums[i] <= 2^31 - 1

思路

开始的想法是只用一个指针去遍历数组，将每次遍历到的零通过冒泡的方式放到数组的最后面。于是我们就要先遍历一遍数组，记录该数组中零的个数，然后通过循环来将每个零放到数组的最后一位。具体代码如下：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int zero_cnt = 0; // 记录0的个数
        for (int k : nums) {
            if (k == 0) zero_cnt++;
        }
		int i = 0; // 定义指针
        while (1) {
			if (!zero_cnt) break;
            if (nums[i] != 0) {
                i++;
            } else {
                // 找到一个0
				zero_cnt--;
                // 将该0放到数组的末尾
                while (i < nums.size() - 1) {
                    nums[i] = nums[i + 1];
                    nums[i + 1] = 0;
                    i++;
                }
                // 操作完成，重置指针
                i = 0;
            }
        }
    }
};

显然，以上做法比较暴力。若零的数量很多，并且数组长度比较长时，每次将零移动到末尾的操作会耗时不少。因此需要考虑优化：通过双指针来操作。

双指针思路

我们定义两个指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。我们将右指针不断向右移动，每次右指针指向非零数时，就将左右指针对应的数交换，同时左指针向右移动。

通过以上操作，我们能够减少交换次数，且整个数组我们只需要遍历一遍，大大的优化了暴力解法遍历多次所消耗的时间复杂度。

那么这个过程是如何操作的呢？我们以下面的输入输出为例

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

开始时左右指针都指向0，由于右指针 right 指向的是0，所以不进行交换操作，直接将 right 往后移。此时 left 指向0，right 指向1，right 指向了非零数，将0和1进行交换，并且 left 往后移。此时，我们就说数组前两位已经排好序，也就是前面所说的左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。根据这个可以知道，left 始终指向0，且该0是已经处理好的序列的最后一位。于是不断通过这个操作，直到 right 移动到数组的末尾即可。

那么我们再考虑特殊情况，假设他给定的数组里没有0，那么通过以上操作可以知道，左右指针始终指向同一个数字，即使进行交换操作也是这个数字自己和自己交换，并不会影响数组的顺序。具体代码如下：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size(), left = 0, right = 0;
        while (right < n) {
            if (nums[right]) {
                swap(nums[left], nums[right]);
                left++;
            }
            right++;
        }
    }
};