算法记录 01 | 704.二分查找，27.移除元素

今日更新题目：704.二分查找，27.移除元素

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        

提示：

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

我的思路

题中关键词，元素有序且不重复，则可利用二分查找，二分查找的关键是如何确定边界

• 停止查询边界
• 比较后left和right边界，是令 left=mid+1 还是 left=mid 呢？

实际上，出现这种问题，主要是因为区间定义不同，记了不同的写法有时容易搞混，不妨就记住一种，个人喜欢用左闭右闭区间的写法。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        
        // left = right 时还需要判断nums[nums]是否等于target
        while(left <= right){
            int middle = left + ((right - left) / 2);
            if(target > nums[mid]){
                left = mid + 1;
            }
            else if(target < nums[mid]){
                right = mid - 1;
            }
            else
                return mid;
        }
        return -1;
    }
};

27.移除元素

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

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

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

我的思路

1. 暴力解法
2. 双指针法（快慢指针）

暴力解法

本题暴力解法其实就是两层for循环，第一个for循环用于遍历数组，第二个for循环用于更新数组，即遇到等于val的值时，则将val之后的所有元素都往前移动一位，即第二个for循环，时间复杂度为 O(n²)

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 暴力解
        int len = nums.size();
        for(int i = 0; i < len; i++){
            if(nums[i] == val){
                for(int j = i; j+1 < len; j++)
                    nums[j] = nums[j+1];
                len--;
                i--;
            }
            
        }
        return len;
    }
};

双指针法（快慢指针法）

上面暴力解法实在是不优美，也缺乏效率，如果多次遇到val值，则每次都要将后面的元素移动一边，没办法保证所有元素的移动一步到位，为了实现一步到位的解法，可以引入快慢指针，最初二者同时出发。

虽然博主第一想法就是快慢指针法，但我还是想麻烦了，最初想法是：

• 快指针：找到val值所对应的索引
• 慢指针：当快指针找到对应索引时，则用慢指针记录其索引
• 快指针++，判断新位置是否为val，不是则更新数组，是则……想到了各种情况，越来越复杂

想到这基本觉得不对了，应该是把简单问题复杂化了

但实际上只要抓住一点：目的是要让移动的元素一步到位，那实际上我们只需要知道后面的元素需要移动多少位即可，也就是快慢指针的差值，差值从何而来，即

• 快慢指针同时出发
• 当 nums[fast] != val 时，快、慢指针正常遍历，并且更新数组，即使快慢指针一样，也可以更新，反正不变；
• 当 nums[fast] == val 时，由于遇到了val值，所以本次不更新，接着快指针多走一步自增（通过for循环自增），慢指针不自增。

想到这，一切就简单了

class Solution {
public:
    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];
            }
        }
        return slow;
    }
};