LeetCode | C++ 704. 二分查找 35. 搜索插入位置 27. 移除元素

704. 二分查找

相较于使用暴力解法O(n)， 二分法的时间复杂度更低为O(log(n))，二分法本身的思路并不复杂，问题在于区间边界，可以通过在纸上简单演示下，即可明确。

方法一：左闭右闭

class Solution {
public:
    int search(vector<int>& nums, int target) {

        // 最开始首先判断 其是否在 数组当中
        if (target < nums[0] || target > nums[nums.size() - 1])
        {
            return -1;
        }

        // 闭区间写法
        //[left, right]
        int left = 0;
        int right = nums.size() - 1;
        // 在这里需要“等于”，是因为当只有一个元素的时候也需要进行判断
        while(right >= left){                
            int mid = left + (right - left) / 2;  // 中间值下标
            if (target > nums[mid]){     // 在右区间 [mid + 1, right]
                left = mid + 1;
            }
            else if (target < nums[mid]){ // 在左区间 [left, mid - 1]
                right = mid - 1;
            }
            else{
                return mid;
            }              
        }
        return -1;
    }
};

方法二：左闭右开

class Solution {
public:
    int search(vector<int>& nums, int target) {

        // 最开始首先判断 其是否在 数组当中
        if (target < nums[0] || target > nums[nums.size() - 1])
        {
            return -1;
        }

        // 左开右闭写法
        // [left, right)
        int left = 0;
        int right = nums.size();
        while(right > left){
            int mid = left + (right - left) / 2;
            if(target > nums[mid]){
                left = mid + 1;
            }
            else if(target < nums[mid]){
                right = mid;
            }
            else{
                return mid;
            }
        }
        return -1;
    }
};

35. 搜索插入位置

二分法应用

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
    
        // 暴力解法
        // for(int i = 0; i < nums.size(); i++) {
        //     if (nums[i] >= target) {
        //         return i;
        //     }
        // }
        // return nums.size();

        // 二分法 左闭右闭区间
        int left = 0;
        int right = nums.size() - 1;
        while(right >= left){
            int mid = left + (right - left) / 2;
            if (target > nums[mid]){
                left = mid + 1;
            }
            else if(target < nums[mid]){
                right = mid - 1;
            }
            else{
                return mid;
            }
        }

        // 程序跳出循环即证明数组中不含有该元素
        // 此时需要过 最后一次 while 循环，
        // 分别看 target > nums[mid] 和 target < nums[mid]情况下返回的值 
        // 通过合并同类项 即得 right + 1;

        return right + 1;

    }
};

27. 移除元素

相较于暴力解法O(n^2)，快慢指针法O(n)的思路比较巧妙，把移除元素这件事转换为构建一个移除元素之后新数组。其中，快指针是用来获取新数组中的元素，而慢指针是获取我们新数组中需要更新的位置。

方法一：暴力解法

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

方法二：快慢指针法

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {

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