LeetCode题解 数组（二）：27、26、283、844、977

27 移除元素 easy

移除相应元素，返回移除后数组的长度

虽然这道题返回类型是int，但是输出结果是数组，因为leetcode中会根据返回的数组长度进行输出。

暴力搜索的解法是O（n^2）的时间复杂度。

这道题很容易想到使用双指针，一快一慢，慢指针指向当前的数组长度，快指针去搜索不等于目标值的元素就可以了

int removeElement(vector<int>& nums, int val) {
    int slow = 0;
    for (int fast = 0; fast < nums.size(); fast++) {
        if (nums[fast] != val) {
            nums[slow] = nums[fast];
            slow++;
        }
    }
    return slow;
}

然而上面的遍历过程并非最优，因为是根据快指针不等于目标值的情况进行赋值的，如果说要移除的元素在数组开始的位置，就需要把后面的数组依次往前移动一位

然而，这道题目，并没有要求移除元素后的数组需要保持原本的顺序，所以可以使用一些邪门歪道：前后遍历，只要是目标值，把后面的元素覆盖在前面的即可

int removeElement(vector<int>& nums, int val) {
    int left = 0, right = nums.size();
    while (left < right) {
        if (nums[left] == val) {
            nums[left] = nums[right - 1];
            right--;
        } else {
            left++;
        }
    }
    return left;
}

26 删除排序数组中的重复项 easy

依旧是双指针法

慢指针指向要赋值的index，快指针找到与慢指针值不同的元素

int removeDuplicates(vector<int>& nums) {
    int slow = 0;
    for (int fast = 1; fast < nums.size();) {
        if (nums[fast] != nums[slow]) {
            slow++;
            nums[slow] = nums[fast];
        } else
            fast++;
    }
    return slow + 1;
}

283 移动零 easy

说是移动零，其实有些障眼法，还不如直接找不是零的数放在前面，后面再用0覆盖就好了

void moveZeroes(vector<int>& nums) {
    int slow = 0;
    for (int fast = 0; fast < nums.size(); fast++) {
        if (nums[fast] != 0) {
            nums[slow] = nums[fast];
            slow++;
        }  
    }
    for (int i = slow; i < nums.size(); i++) {
        nums[i] = 0;
    }
}

844 比较含退格的字符串 easy

借用LeetCode 官方题解中的解释：

一个字符是否会被删掉，只取决于该字符后面的退格符，而与该字符前面的退格符无关。因此当我们逆序地遍历字符串，就可以立即确定当前字符是否会被删掉。
具体地，我们定义 skip 表示当前待删除的字符的数量。每次我们遍历到一个字符：

• 若该字符为退格符，则我们需要多删除一个普通字符，我们让 skip 加 1；
• 若该字符为普通字符：
  • 若 skip 为 0，则说明当前字符不需要删去；
  • 若 skip 不为 0，则说明当前字符需要删去，我们让 skip 减 1。

这样，我们定义两个指针，分别指向两字符串的末尾。每次我们让两指针逆序地遍历两字符串，直到两字符串能够各自确定一个字符，然后将这两个字符进行比较。重复这一过程直到找到的两个字符不相等，或遍历完字符串为止。

bool backspaceCompare(string S, string T) {
    int sSkipNum = 0; // 记录S的#数量
    int tSkipNum = 0; // 记录T的#数量
    int i = S.size() - 1;
    int j = T.size() - 1;
    while (1) {
        while (i >= 0) { // 从后向前，消除S的#
            if (S[i] == '#') sSkipNum++;
            else {
                if (sSkipNum > 0) sSkipNum--;
                else break;
            }
            i--;
        }
        while (j >= 0) { // 从后向前，消除T的#
            if (T[j] == '#') tSkipNum++;
            else {
                if (tSkipNum > 0) tSkipNum--;
                else break;
            }
            j--;
        }
        // 后半部分#消除完了，接下来比较S[i] != T[j]
        if (i < 0 || j < 0) break; // S 或者T 遍历到头了
        if (S[i] != T[j]) return false;
        i--;j--;
    }
    // 说明S和T同时遍历完毕
    if (i == -1 && j == -1) return true;
    return false;
}

977 有序数组的平方 easy

最简单的方法是先遍历一遍，平方化

然后再排序

进阶要求是使用时间复杂度为O(n)的算法

由于原数组是排过序的，所以可以前后平方后比较，选择较大的置于一个新数组中的最末尾处，代码如下：

vector<int> sortedSquares(vector<int>& nums) {
    int len = nums.size();
    vector<int> res(nums.size());
    for (int i = 0, j = len - 1, pos = len - 1; i <= j;) {
        if (nums[i] * nums[i] > nums[j] * nums[j]) {
            res[pos] = nums[i] * nums[i];
            i++;
        } else {
            res[pos] = nums[j] * nums[j];
            j--;
        }
        pos--;
    }

    return res;
}