LeetCode 数组 ---- 移除元素合集 (27 / 26 / 997 / )

基础题：27. 移除元素

思路

1. 暴力方法
   这个题目暴力的解法就是两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组。

2. 双指针法
   - 慢指针指向最终需要被使用的数组下标；快指针一直向后寻找不是val的元素
   - 当快指针找到不是val的元素，则将快指针指向的元素赋值给慢指针指向的位置，然后快慢指针同时前进
   - 如果快指针找到了val，则跳过继续向后寻找不是val的元素

代码实现(java)

1. 暴力方法

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;
    }
};

2. 双指针法

class Solution {
    public int removeElement(int[] nums, int val) {
        int fastIndex = 0;
        int slowIndex = 0;

        // 快慢指针，慢指针指向最终需要被使用的数组下标
        // 快指针一直向后寻找不是val的元素
        // 当快指针找到不是val的元素，则将快指针指向的元素赋值给慢指针指向的位置，然后快慢指针同时前进
        // 如果快指针找到了val，则跳过继续向后寻找不是val的元素
        for (fastIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
}

26. 删除有序数组中的重复项

思路

双指针法
慢指针记录被需要替换的位置；快指针记录要替换慢指针的元素位置
循环遍历nums数组，当发现快指针位置元素与快指针下一个位置元素不相等时，就将下一个元素赋值给慢指针下一个位置
以此类推
图示(代码随想录)

代码实现(java)

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 1) return nums.length;

        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.length - 1; fastIndex++) {
            if (nums[fastIndex] != nums[fastIndex + 1]) {  // 发现当前位置与后一个位置元素不同
                // 因为slowIndex = 0一定不重复，所以 ++slowIndex 位置替换为 falstIndex + 1 位置元素
                nums[++slowIndex] = nums[fastIndex + 1];
            }
        }
        // 返回slowIndex + 1, 因为slowIndex目前为被替换的最后一个元素位置，而下一个位置也是新元素，所以+1
        // 具体可看图示
        return slowIndex + 1;
    }
}

977. 有序数组的平方

思路

数组其实是有序的， 只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。
定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

• 如果A[i] * A[i] < A[j] * A[j] 那么result[k–] = A[j] * A[j]; 。
• 如果A[i] * A[i] >= A[j] * A[j] 那么result[k–] = A[i] * A[i]; 。
  图示(代码随想录)

代码实现(java)

class Solution {
    public int[] sortedSquares(int[] nums) {
        // 暴力
        // for (int i = 0; i <nums.length; i++) {
        //     nums[i] = Math.abs(nums[i] * nums[i]);
        // }
        // Arrays.sort(nums);
        // return nums;

		// 双指针
        int[] result = new int[nums.length];
        int left = 0;
        int right = nums.length - 1;
        int index = result.length - 1;
        while (left <= right) {
            int i = nums[left] * nums[left];
            int j = nums[right] * nums[right];
            if (i < j) {
                result[index--] = j;
                --right;
            } else {
                result[index--] = i;
                ++left;
            }
        }
        return result;
    }
}