代码随想录训练营第一天|双指针

lc704二分查找

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

27移除元素

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

数组问题优先考虑双指针 

977有序数组的平方

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n=nums.size();
        int i=0, j=n-1,cur=n-1;
        vector<int> res(n,0);
        while(i<=j){
            if(nums[j]*nums[j]>nums[i]*nums[i]){
                res[cur--]=nums[j]*nums[j];
                j--;
            }
            else{
                res[cur--]=nums[i]*nums[i];
                i++;
            }
        }
        return res;
    }
};

原数组有序，平方后以0为界，依然可以得到两个有序数组，后续操作类似于归并。无法inplace操作，否则元素被覆盖。 

35.搜索插入位置

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

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

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

    int searchRight(vector<int>& nums, int target) {
        int left=0, right=nums.size()-1,right_border=-1;
        while(left<=right){
            int mid=(left+right)/2;
            if(target>nums[mid]){
                left=mid+1;
            }
            else if(target<nums[mid]){
                right=mid-1;
            }
            else{
                right_border=mid;
                left=mid+1;
            }
        }
        return right_border;
    }
    vector<int> searchRange(vector<int>& nums, int target) {
        int l=searchLeft(nums,target);
        int r=searchRight(nums,target);
        return {l,r};
    }
};

查找到元素后不急于返回，而是调整搜索区间，让其逼近边界。考虑到取值范围是[left,right]，边界点均可取到，所以right=mid-1，尝试往更小的方向搜索，得到下界；left=mid+1，尝试往更大的方向搜索，得到上界。