Day01打卡.二分查找法与移除元素法

二分查找法

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

• 对应LeetCode704题

第一种二分代码

• target所对应的区间是左闭右闭型区间，也就是[left,right]

  • 那么在while循环中的判断条件需要加等号，也是因为left==right符合条件，有意义

  • 除此之外，nums[mid]>target 的if语句中，right=mid-1，因为当前的mid已经判断过了，不是target，且区间是左闭右闭区间，所以下次查找的右区间需要-1,而nums[mid]<target时，同理需要加1

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

• 此算法的时间复杂度O(log n)

• 空间复杂度O(1)

第二种二分代码

• target所对应的区间是左闭右开型区间，也就是[left,right）

• 那么在while循环中的判断条件不需要加等号，也是因为left==right不符合条件，没有意义，while (left < right)

• 除此之外，nums[mid]>target 的if语句中，right=mid，因为当前区间是右开的，所以mid一定不是target，所以查找右区间是mid，查找过程也不会去比较nums[mid]，而左区间是闭区间，和第一种相同left=mid+1

class Solution {
public:
    int search(vector<int>& nums, int target) {
        
        int left =0;
        int rignt = nums.size();// 定义target在左闭右开的区间里，即：[left, right)
        while(left<rignt){
// 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int mid = (left+rignt)/2;
            //或者 int mid = left + ((right - left) >> 1); >>1也相当于/2
            if(nums[mid]>target){
                rignt=mid; // target 在左区间，在[left, middle)中
            }
            else if(nums[mid]<target){
                left =mid +1; // target 在右区间，在[middle + 1, right)中
            }
             // nums[middle] == target
            else return mid;
        // 数组中找到目标值，直接返回下标
        }
​
        return -1;  //未找到目标值
        
    }
};

• 此算法的时间复杂度O(log n)

• 空间复杂度O(1)

移除元素

• 题目：

  给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

  不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

  元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

  示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

  示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

  你不需要考虑数组中超出新长度后面的元素。

• 对应LeetCode:27

暴力解法

• 利用两层for循环,但是时间复杂度是O(2^n)

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size=nums.size();
        for(int i = 0; i<size;i++){
            if(nums[i]==val){  // 发现需要移除的元素，就将数组集体向前移动一位
                for(int j=i+1;j<size; j++){
                    nums[j-1]=nums[j];
                }
                i--;  // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;
    }
};

• 此处我犯的错误在于没加i-- 导致用例是{1,2，2，3,4}中删除2元素不通过，因为删除第一个2后，i指针没有向前移动，导致内层循环结束后外侧循环i++到3元素，跳过了一个2，删除失败

双指针法

• 双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

• 快指针fast：寻找新数组的元素 ，新数组就是不含有目标元素的数组

• 慢指针slow：指向更新 新数组下标的位置

• 此方法是利用两个指针，一个进行寻找，另一个进行填补，若不是目标值的话，就将fast指向的元素赋给slow,若是目标值，则fast跳过，而slow不动，后续继续查找，不是的话，将fast指向的元素赋值给slow，刚好能覆盖住目标元素，即为删除，最后返回slow，而slow后的元素不用管,因为数组也是一种数据结构，不需要考虑后面的,且这些实现方法并没有改变元素的相对位置

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;
    }
};

• 时间复杂度为O(n)

• 空间复杂度为O(1)

相向双指针法

• 该方法改变了元素的相对位置，但是可以解决本题

• 时间复杂度也是O(n)

//相向双指针法
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0;
        int right = nums.length - 1;
        while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置
        while(left <= right) {
            if(nums[left] == val) { //left位置的元素需要移除
                //将right位置的元素移到left（覆盖），right位置移除
                nums[left] = nums[right];
                right--;
            }
            left++;
            while(right >= 0 && nums[right] == val) right--;
        }
        return left;
    }
}