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

704.二分查找

力扣题目链接
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

二分查找使用前提：有序数组+数组中无重复元素
时间复杂度O(logn)，空间复杂度O(1)

1. 左闭右闭[left,right]

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left=0,right=nums.size()-1;
        while(left<=right){
            int mid=left+((right-left)/2); //防止溢出
            if(nums[mid]==target)
                return mid; 
            else if(nums[mid]>target)
                right=mid-1;
            else
                left=mid+1;
        }
        return -1;
    }
};

2. 左闭右开[left,right)

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left=0,right=nums.size();
        while(left<right){
            int mid=left+((right-left)/2); //防止溢出
            if(nums[mid]==target)
                return mid; 
            else if(nums[mid]>target)
                right=mid;
            else
                left=mid+1;
        }
        return -1;
    }
};

总结：解决开区问题的关键是区间边界是否有意义，即结果是否能够取到该边界

27.移除元素

力扣题目链接
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

1. 暴力法 时间复杂度O(n^2) 空间复杂度O(1)
   算法：两层for循环，外层遍历数组，内层删除元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
       int n=nums.size();
       for(int i=0;i<n;i++){ //遍历数组
           if(nums[i]==val){
               for(int j=i+1;j<n;j++){ //删除元素
                   nums[j-1]=nums[j];
               }
               i--; //原位置填充了新的元素，因此要重新比较
               n--;
           }
       }
        
        return n;
    }
};

2. 双指针法 时间复杂度O(n) 空间复杂度O(1)
   算法：双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个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) //当快指针的值与val不同时，存储元素到慢指针中
                nums[slow++]=nums[fast];
        }
        
        return slow;
    }
};

3. 优化双指针 时间复杂度O(n) 空间复杂度O(1)

   算法：双指针，一首一尾，向中间移动遍历

   • 左指针判断是否相等，若相等，则右指针的值赋值到左指针，右指针-1
   • 利用右指针的值替换不需要的元素

利用左指针判断相等的原因：右指针的值可以丢弃，因此用左边保留元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int left=0,right=nums.size()-1;
        while(left<=right){
            if(nums[left]==val){
                nums[left]=nums[right]; //相等，则右指针的值赋值到左指针
                right--;
            }
            else
                left++;
        }
        return left;
    }
};

优化双指针仅需遍历数组一遍就可，而原双指针至多遍历数组两遍

4. 相向双指针 时间复杂度O(n) 空间复杂度O(1)

   算法：同三，写法类似快排

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;
            }
            // 将右边不等于val的元素覆盖左边等于val的元素
            if (leftIndex < rightIndex) {
                nums[leftIndex++] = nums[rightIndex--];
            }
        }
        return leftIndex;   // leftIndex一定指向了最终数组末尾的下一个元素
    }
}