代码随想录算法训练营第一天 | 704. 二分查找 27. 移除元素

今天是2024年5月22日，尝试开始写博客记录学习日常

今天主要学习了数组问题中的二分查找，移除元素

Leetcode 704. 二分查找 

就是求中点，用中点去匹配target，返回中点

文章讲解：代码随想录

左闭右闭：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //左闭右闭[ ] <=right
        int left = 0;        // left right middle target 是下标
        int right = nums.size()-1;
        while(left<=right){
/*中点=左边的起点+left到right的1/2长度 同（right + left)/2 这样是为了防止int溢出 即middle = left + [left , right]/2 */
            int middle = left + (right - left)/2; 
            //target在中点左边  
            if (target < nums[middle]){
                right = middle-1;
            //target在中点右边
            } else if( target > nums[middle]){
                left = middle+1;
            }else {
                return middle;
            }
        }

    return -1;

    }
};

左闭右开：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //左闭右开 [ )   <right
        int left = 0;        // left right middle target 是下标
        int right = nums.size();
        while(left<right){
            int middle = left + (right - left)/2;   
            if (target < nums[middle]){
                right = middle;
            } else if( target > nums[middle]){
                left = middle+1;
            }else {
                return middle;
            }
        }

    return -1;

    }
};

LeetCode 27. 移除元素

文章讲解：代码随想录

暴力解法：

for*for , 时间复杂度 O(n^2)

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //数组长度
        int size = nums.size();
        //遍历启动器
        for (int i=0; i<size;i++){
            //判断遍历的元素是否等于val
            if(nums[i]==val){
                //如果第i元素等于val，就把它后一位的元素向前覆盖
                //因为数组的元素在内存空间中连续的，只能覆盖
                //另一个遍历启动，后一位i+1的元素连续向前覆盖,到[size]停
                for(int j=i+1; j<size; j++){
                    //j位覆盖j-1位即前一位
                    nums[j-1] = nums[j];
                }
                i--; //i遍历次数要一起减少，否则会继续遍历没删减前的次数，数组长度会出错
                size--; //数组长度减少

            }
        }
        return size; //返回最终数组长度
}
};

快慢双指针：

用两个指针的遍历位差去更新数组，时间复杂度O(n), 库函数 .erase() 原理

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //数组长度
        int size = nums.size();
        //初始化快，慢指针，快指向要保留（进行前移覆盖）的元素，慢指向需要被覆盖的元素下标
        int fastindex=0,slowindex=0;
        //快指针开始遍历
        for (fastindex ; fastindex<size;fastindex++){
        //判断快指针是否指向需要保留的元素，如果是，则更新元素到慢指针所指的位置进行覆盖
            if(nums[fastindex]!=val){
                nums[slowindex++]=nums[fastindex];  
            }
        }
//最后慢指针所指的位置必定是不需要的元素，而对应的下标正好是更新后数组的长度，因为数组下标从0开始
        return slowindex;

}
};

//nums[slowindex++] 相当于nums[slowindex]更新后 slowindex++