代码随想录第一天，数组基础知识和二分查找

数组基础

27. 移除元素

解题思路：

这题阅读题目，题意为，给定val，将val全部去除，然后数组只剩下了其他值，如果要这样按照题意实现的话，可能不太现实，因为数组是个连续的内存单元，我们没办法将某一个内存去除，所以这个题目提交的要求就是，去除val后的数组长度，就是答案的判定范围，所以我们只需要将不满足val的值移到前面。

我们想要实现将所有不满足val的值移到前面，如果不需要删除的数有10个，那么数组前面十个空间放这十个数，这里有几种情况

第一种情况

val都在前面

这时候我们可以定义两个指针，一个指向val，一个指向不是val的，然后用循环，每次将后面的指针指向的数值移到前面，移动不满足的数的个数次即可

第二种情况，满足的和不满足的混在一起，这时候就不能无脑交换了，只有在后面一个指针指向的数据不为val时才换，这样才能维护数组数据都是对的，而不会把val移动到前面

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 这题思路就是把不移除的值移到前面
        // 遍历整个数组，将所有不等于val的值移到前面

        int count = 0;
        for (int l = 0, r = 0; r < nums.size(); r++)
        {
            if (nums[r] != val)
            {
                nums[l] = nums[r];
                l++;
                count++;    //用来计数数组长度
            }
        }
        return count;
    }
};

704. 二分查找

解题思路

众所周知，在单调的情况，如果我们在区间中选择一个点，那么这个点两边要不是全小于这个点，要不就全大于这个点，所以我们查找的时候，每次就查区间中点，然后每次分割为区间的一半进行查找

class Solution {
public:
    int search(vector<int>& nums, int target) 
    {
        int l = 0, r = nums.size() - 1;
        int mid = l + r >> 1;
        while (l <= r)
        {
            mid = l + r >> 1; 
            if (nums[mid] < target)
            {
                l = mid + 1;
            }
            else if (nums[mid] > target)
            {
                r = mid - 1;
            }
            else
            {
                return mid;
            }
        }
        return -1;
    }
};

35. 搜索插入位置

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        int mid = l + r >> 1;
        while (l <= r)
        {
            mid = l + r >> 1;
            if (target < nums[mid]) r = mid - 1;
            else if (target > nums[mid]) l = mid + 1;
            else return mid;
        }
        return l;
    }
};

34. 在排序数组中查找元素的第一个和最后一个位置

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        // 初始化二分的中点
        int l = 0, r = nums.size() - 1;
        int mid = (l + r) >> 1;


        // 初始化结果数组
        vector<int> res = {-1, -1};

        // 查找左边界  
        while (l < r)
        {
            mid = (l + r) >> 1;
            if (target > nums[mid]) l = mid + 1;
            else r = mid;
        }
        if (r < nums.size() && nums[r] == target) {
            res[0] = r;
        } else {
            // 如果没有找到左边界，直接返回结果
            return res;
        }


        // 查找右边界,因为查找左边界把l r 和mid初始值改变了，所以要先初始化
        l = 0; 
        r = nums.size() - 1;
        mid = (l + r + 1) >> 1;

        while (l < r)
        {
            mid = (l + r + 1) >> 1;
            if (target >= nums[mid]) l = mid;
            else r = mid - 1;
        }
        if (nums[l] == target)
        {
            res[1] = l;
        }

        return res;
    }
};