Day 1 | LeetCode 刷题

打卡日期：2024.1.11
题目：LeetCode 704 二分查找 、LeetCode 27 移除元素

704 二分查找

二分法使用的前提条件：

• 有序数组
• 无重复元素

关键点：想清楚区间的定义（不变量），是 [left, right] 还是 [left, right)，
在while循环中始终坚持按照 查找区间的定义 来做 边界处理。

C++解法

（此处我定义区间为左闭右闭）

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;    // 定义target在左闭右闭的区间里[left, right]

        while (left <= right) {
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle - 1;
            }else if (nums[middle] < target) {
                left = middle + 1;
            }else{
                return middle;
            }
        }
        // 未找到目标
        return -1;
    }
};

27 移除元素

注意：

• 数组（array）一旦定义，大小就是固定的。数组的元素是不能删的，只能覆盖
• vector 是动态数组，使用push back添加元素或pop_back()删除元素

C++解法

法一：暴力解法

解题思路：
因为数组不能删除元素，只能覆盖，故使用两次 for 循环来解决。第一次 for 循环遍历数组元素，第二次 for 循环更新数组（覆盖元素）

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; j<size-1; j++){
                    nums[j] = nums[j+1];
                }
                i--;    // for 循环中i++，故要--从nums[i]开始重新判断覆盖的内容
                size--;    // 数组大小减一
            }
        }
        return size;
    }
};

法二：双指针法（快慢指针）

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。

双指针法（快慢指针法）：通过一个快指针和一个慢指针在一个 for 循环中完成两个 for 循环的工作

定义快慢指针：

• 快指针：寻找新数组（不含有目标元素的数组）的元素，即寻找更新的内容
• 慢指针：指向新数组（被更新数组）的下标位置

将快指针指向的内容赋值给慢指针指向的位置，当快指针遍历完整个数组，全部更新完成，慢指针指向的位置即为新数组的大小。

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];
                slowIndex++;
            }
        }
        return slowIndex;
    }
};

该方法并未改变元素之间的相对位置。

法三：相向双指针法

相向双指针法改变了元素间的相对位置，确保移动最少元素。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int leftIndex = 0;
        int rightIndex = nums.size() - 1;
        while (leftIndex <= rightIndex) {
            // 找到左边等于val的元素（要更新的位置）
            while (leftIndex<=rightIndex && nums[leftIndex]!=val) {
                leftIndex++;
            }
            // 找到右边不等于val的元素（更新的内容）
            while (leftIndex<=rightIndex && nums[rightIndex]==val) {
                rightIndex--;
            }
            // 找到后用nums[rightIndex]覆盖nums[leftIndex]
            if (leftIndex<rightIndex) {
                nums[leftIndex] = nums[rightIndex];
                leftIndex++;
                rightIndex--;
            }
        }
        return leftIndex;
    }
};

​