[LeetCode] 数组I ——二分查找(704#)&双指针法(27#, 977#)

数组

存放在连续内存空间上的相同类型数据的集合

数组的元素是不能删除，只能覆盖

因为数组在内存空间的地址是连续的，所以在删除或者增添元素的时候，就难免要移动其他元素的地址

在C++中二维数组也是连续分布的

二分查找

前提：数组为有序数组，数组中无重复元素（即结果唯一）

定义查找的范围 [left,right]，每次取查找范围的中点 mid，比较 nums[mid] 和 target 的大小

循环不变量规则：在二分查找的过程中，保持不变量（区间的定义），在循环中坚持根据查找区间的定义来做边界处理

注意：while(left < right) or while(left <= right)，right = middle or right = middle - 1 与区间开闭相关

Tips:

(right - left) >> 1 等同于 (right - left) / 2

704# 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

定义查找的范围 [left,right]，初始查找范围是整个数组。每次取查找范围的中点 mid，比较 nums[mid] 和 target 的大小，如果相等则 mid 即为要寻找的下标，如果不相等则根据 nums[mid] 和 target 的大小关系将查找范围缩小一半

由于每次查找都会将查找范围缩小一半，因此二分查找的时间复杂度是 O(log n)，其中 n 是数组的长度

// 0ms O(log n); 30.71MB O(1)
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while(left <= right) {
            int mid = left + (right - left) / 2;
            int num = nums[mid];
            if (target == num) {
                return mid;
            } else if (target < num) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
};

双指针法

通过一个快指针和慢指针在一个for循环下完成两个for循环的工作

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

27# 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

• 更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
• 返回 k。

用户评测：

评测机将使用以下代码测试您的解决方案：

int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
                           // 它以不等于 val 的值排序。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {
   assert nums[i] == expectedNums[i];
}

如果所有的断言都通过，你的解决方案将会 通过。

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,_,_,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

// 初次尝试，需要额外定义一个vector
// 0ms O(n); 11.78MB O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int length = nums.size();
        int count = 0;
        std::vector<int> temp(length);
        for (int i = 0; i < length; i++) {
            if (nums[i] != val) {
                temp[count] = nums[i];
                count++;
            }
        }
        nums = temp;
        return count;
    }
};

// 双指针法
// 0ms O(n); 11.65MB O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

977# 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

数组是有序的整数数组， 那么数组平方的最大值就在数组的两端，因此用双指针法比较两端的大小

// 双指针法
// 0ms O(n); 29.56MB O(1)
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        vector<int> result(n, 0);
        for (int i = 0, j = n - 1, pos = n - 1; i <= j;) {
            if (nums[i] * nums[i] < nums[j] * nums[j]) {
                result[pos--] = nums[j] * nums[j];
                j--;
            } else {
                result[pos--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};