Day1-数组-二分查找(力扣704、35)和移除元素(力扣27、26、287)

主要算法

二分查找和双指针法(快慢指针法)

二分查找

基础题:704. 二分查找

这道题就是基础的二分查找,主要理解当循环条件为(left<=right)或(left<right)时循环内部语句的不同.

方法一:左闭右闭[left,right]

int search(int* nums, int numsSize, int target){
    int left = 0;
    int right = numsSize-1;
    int middle = 0;
    //若left小于等于right，说明区间中元素不为0
    while(left<=right) {
        //更新查找下标middle的值
        middle = (left+right)/2;
        //此时target可能会在[left,middle-1]区间中
        if(nums[middle] > target) {
            right = middle-1;
        } 
        //此时target可能会在[middle+1,right]区间中
        else if(nums[middle] < target) {
            left = middle+1;
        } 
        //当前下标元素等于target值时，返回middle
        else if(nums[middle] == target){
            return middle;
        }
    }
    //若未找到target元素，返回-1
    return -1;
}

方法二:左闭右开[left,right)

int search(int* nums, int numsSize, int target){
    int length = numsSize;
    int left = 0;
    int right = length;	//定义target在左闭右开的区间里，即：[left, right)
    int middle = 0;
    while(left < right){  // left == right时，区间[left, right)属于空集，所以用 < 避免该情况
        int middle = left + (right - left) / 2;
        if(nums[middle] < target){
            //target位于(middle , right) 中为保证集合区间的左闭右开性，可等价为[middle + 1,right)
            left = middle + 1;
        }else if(nums[middle] > target){
            //target位于[left, middle)中
            right = middle ;
        }else{	// nums[middle] == target ，找到目标值target
            return middle;
        }
    }
    //未找到目标值，返回-1
    return -1;
}

推荐题:35.搜索插入位置

这道题目，要在数组中插入目标值，无非是这四种情况。

• 目标值在数组所有元素之前
• 目标值等于数组中某一个元素
• 目标值插入数组中的位置
• 目标值在数组所有元素之后

方法一:暴力解法

int searchInsert(int* nums, int numsSize, int target) {

    for(int i=0;i<numsSize;i++)
    {
        if(target==nums[i]) return i;//数组中存在该元素
        
        if(target<nums[0]) return 0;//插入数组的第一个位置
        
        if(target>nums[i]&&target<nums[i+1]) return i+1;//插入数组中间
    }
    return numsSize;//插入数组末尾
}

方法二:二分查找

int searchInsert(int* nums, int numsSize, int target) {
    int left=0;
    int right=numsSize-1;
    int mid;

    while(left<=right)
    {
        mid=(left+right)/2;
        if(nums[mid]==target) return mid;//在数组中找到了该元素

        else if(nums[mid]<target)
            left=mid+1;
        else 
            right=mid-1;
    }
    return right+1;
}

注意,无论是哪种情况最后对应的返回值为 right+1.这里开始的想法是声明一个变量记录插入的位置,不过没有成功而且也没有必要. 

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

该题目有3种情况

1.数组中没有该元素,返回[-1,-1]

2.数组中只有一个元素值符合要求

3.数组中有两个元素符合要求

方法一:暴力解法

int* searchRange(int* nums, int numsSize, int target, int* returnSize) {
    *returnSize=2;
    int* returnnum=(int*)malloc(2*sizeof(int));
    returnnum[0]=-1;
    returnnum[1]=-1;

    for(int i=0;i<numsSize;i++)
    {

        if((returnnum[0]==-1)&&(nums[i]==target))//当第一次找到target时才执行该语句
        {
            returnnum[0]=i;
            returnnum[1]=i;
        }

       
        if((returnnum[0]!=-1)&&(nums[i]==target))//当第二次找到target时才执行该语句
        {
            returnnum[1]=i;
        }
    }
    return returnnum;
}

该方法就是将整个数组游历一边,然后记录元素的下标位置.

方法二:二分查找(两次)

int searchLeftBorder(int *nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    // 记录leftBorder没有被赋值的情况
    int leftBorder = -1;
    // 边界为[left, right]
    while (left <= right) {
        // 更新middle值，等同于middle = (left + right) / 2
        int middle = left + ((right - left) >> 1);
        // 若当前middle所指为target，将左边界设为middle，并向左继续寻找左边界
        if (nums[middle] == target) {
            leftBorder = middle;
            right = middle - 1;//继续向左寻找边界
        } else if (nums[middle] > target) {
            right = middle - 1;
        } else {
            left = middle + 1;
        }
    }
    return leftBorder;
}
int searchRightBorder(int *nums, int numsSize, int target) {
    int left = 0, right = numsSize - 1;
    // 记录rightBorder没有被赋值的情况
    int rightBorder = -1;
    while (left <= right) {
        int middle = left + ((right - left) >> 1);
        // 若当前middle所指为target，将右边界设为middle，并向右继续寻找右边界
        if (nums[middle] == target) {
            rightBorder = middle;
            left = middle + 1;//继续向右寻找边界
        } else if (nums[middle] > target) {
            right = middle - 1;
        } else {
            left = middle + 1;
        }
    }
    return rightBorder;
}

int* searchRange(int* nums, int numsSize, int target, int* returnSize){
    int leftBorder = searchLeftBorder(nums, numsSize, target);
    int rightBorder = searchRightBorder(nums, numsSize, target);

    // 定义返回数组及数组大小
    *returnSize = 2;
    int *resNums = (int*)malloc(sizeof(int) * 2);
    resNums[0] = leftBorder;
    resNums[1] = rightBorder;
    return resNums;
}

该方法使用两个二分查找分别寻找左边界和右边界(计算出来的右边界是不包含target的右边界,左边界同理.)推荐新手使用这个方法,而不是在一个函数中同时寻找左右边界

移除元素

基础题:27.移除元素

本题要注意将移除元素之后的元素全部向前移

方法一:暴力解法

该方法是用两个for循环,外循环遍历数组,内循环中将删除的元素之后的元素全部向前移一格

方法二:双指针法

int removeElement(int* nums, int numsSize, int val) {
    int slow=0;
    int fast=0;
    for(;fast<numsSize;fast++)
        if(nums[fast]!=val)
            nums[slow++]=nums[fast];
    return slow;
}

该方法运用两个"指针",慢指针用来指向新数组的下标,快指针用来遍历原数组,当快指针指向的元素不等于目标值时就将该元素赋给慢指针.

推荐题:26.删除有序数组中的重复项

方法一:普通解法(其实也用到了双指针)

int removeDuplicates(int* nums, int numsSize)
{
    int j=1;//操作后的数组下标
    int ch=nums[0];
    for(int i=1;i<numsSize;i++)
    {
        if(!(ch==nums[i]))
        {
            ch=nums[i];
            nums[j]=ch;
            j++;
        }
    }
    return j;
}

该方法用一个变量ch记录数组的第一个值,j为新数组的下标.i从下标为1的位置开始遍历数组,当i位置的值等于ch时i加1,不等于时则将nums[i]赋值给nums[j],然后用ch记录下该值同时j加1.

方法二:双指针法

int removeDuplicates(int* nums, int numsSize) {
    if(numsSize==0)
        return 0;


    int slow=0;
    int fast=1;
    
    while(fast<numsSize)
    {
        if(nums[fast]==nums[slow])
            fast++;
        else
            nums[++slow]=nums[fast];
    }
    
    return slow+1;
}

这个方法就是基本的双指针法,不过我循环内部的选择条件用的==,其实用!=更好.

推荐题:283.移动零

方法一:官方题解(不好理解)

void swap(int *a, int *b) {
    int t = *a;
    *a = *b, *b = t;
}

void moveZeroes(int *nums, int numsSize) {
    int left = 0, right = 0;
    while (right < numsSize) {
        if (nums[right]) {
            swap(nums + left, nums + right);
            left++;
        }
        right++;
    }
}

这个代码看起来不好理解,其实就两句话总结1.非0快慢指针都加1 2.为0交换快慢指针中的值,同时快指针加1,慢指针不变

来自力扣题解

方法二:双指针

void moveZeroes(int* nums, int numsSize) {
    int slow=0,fast=0;
    int X=0;//0出现的次数

    for(;fast<numsSize;fast++)
    {
        if(nums[fast]==0)
            X++;
        else
            nums[slow++]=nums[fast];
    }

    if(X!=0)
        for(;X>0;X--)
            nums[slow++]=0;
}

该方法就是多一个变量X来记录0出现的次数.因为双指针中的快指针会将数组完整的遍历一遍,当出现0时X自增1.当执行完循环后(即非0项都已经排好了)再将0添加到数组中.

总结

出现的问题:

1.26中最后的返回值应该为slow+1,开始写成slow,其实就是没完全理解题意.

2.在选择语句的条件中总是想不到使用!=.