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

Leetcode 704 二分查找

题目链接：704二分查找

介绍

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

思路

先看看一个动画，可以看出二分查找只用了3次即可查找成功，而顺序查找却要用12次。

二分查找算法的原理如下：

1. 设置查找区间：low = 0；high= n；

2. 若查找区间[low, high]不存在，则查找失败；否则转步骤3

3. 取中间位mid = (low + high) / 2；比较 target 与 arr[mid]，有以下三种情况：

3.1 若 target < arr[mid]，则high = mid - 1；查找在左半区间进行，转步骤2；

3.2 若 target > arr[mid]，则low = mid + 1；查找在右半区间进行，转步骤2；

3.3 若 target = arr[mid]，则查找成功，返回 mid 值；

二分法易错点：边界问题—一般情况下，写二分法时，要么是左闭右闭，要么是左闭右开，区间不一样时，会影响边界条件的处理。

1. while(left<right) 还是while(left<=right)

2. if(target<nums[middle]) right = mid 还是right = mid -1

左闭右闭：

left = 0
right = num.size-1
while(left<=right){ //[1,1]时left=right是合法区间
    middle = (left+right)/2
    if(target < nums[middle])    right = middle - 1;
    else if(target > nums[middle]) left = middle + 1;
    else return middle;
}
return -1
}

左闭右开：

left = 0
right = num.size
while(left<right){ //[1,1)开不包含右边界，闭包含左边界，这里又包含又不包含说明不是一个合                         法的区间
    middle = (left+right)/2
    if(target < nums[middle])    right = middle;
    else if(target > nums[middle]) left = middle + 1;
    else return middle;
}
return -1
}

代码

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

Leetcode 27 移除元素

题目链接：27 移除元素

介绍

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

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

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

思路

数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。即在数组中如果要删除x，那么就得让x后面的元素一个个覆盖到前一个上去。c++中的vector，或java/python会提供数组的接口，删除元素后，返回的数组size会-1，但并不代表实际空间-1。例如：vector.erase（）可以删除数组中的某一个元素，实际上这个函数也是进行了一个覆盖的操作，时间复杂度为O(n)。

思路一：暴力实现

两层for循环，第一层for循环遍历数组，找到要删除的元素；第二层for循环将要删除元素后面的元素覆盖到前面来。

思路二：双指针思路O(n)

使用一层for循环做了两层for循环所做的事。

定义一个快指针fastIndex，获取新数组中的元素

定义一个慢指针slowIndex，指向更新新数组下标的位置

开始的时候fastIndex移动，直到找到所要删除的元素后，给慢指针slowIndex赋值。将fastIndex++（指向后一个元素方便覆盖），然后将nums[fastIndex]的值赋给nums[slowIndex]，再将fastIndex++,slowIndex++。

slow = 0;
for(fast=0;fast<nums.size;fast++){
    if(nums[fast]！=val){
        nums[slow] = nums[fast];//把快指针指向的值赋给慢指针所在的位置
        slow++ //慢指针++
    }
    //如果nums[fast]==val，就只需要让fast++就行，也就是继续进行for循环中的fast++操作
    //最后slow所指向的下标的位置，就是新数组的大小
}
return slow;

代码

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