Leetcode刷题：二分查找

一、算法核心内容

二分查找也常被称为二分法或者折半查找，每次查找时通过将待查找区间分成两部分并只取一部分继续查找，将查找的复杂度大大减少。对于一个长度为 O(n) 的数组，二分查找的时间复杂度为 O(logn)。

二、题目

2.1Leetcode69

2.1.1题目描述

实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

2.1.2输入输出格式

输入: 8
输出: 2
说明: 8 的平方根是 2.82842…,
由于返回类型是整数，小数部分将被舍去。

2.1.3代码

class Solution {
public:
    int mySqrt(int x) {
        if(x==0) return 0;
        int left=1,right=x,mid,ans;
        while(left<=right){
            mid=left+(right-left)/2;
            ans=x/mid;
            if(ans==mid){
                return ans;
            }else if(ans>mid){
                left=mid+1;
            }else if(ans<mid){
                right=mid-1;
            }
        }
        return (right>left)?left:right;
    }
};

2.2Leetcode34

2.2.1题目描述

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。

2.2.2输入输出格式

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

2.2.3代码

class Solution {
public:
    int getuppernum(vector<int>& nums, int target){
        int left=0,right=nums.size()-1,mid=0,ans=0;
        while(left<=right){
            mid=left+(right-left)/2;
            ans=nums[mid];
            if(ans>target){
                right=mid-1;
            }else if(ans<target){
                left=mid+1;
            }else{
                if(mid==nums.size()-1 || nums[mid+1]!=target){
                    return mid;
                }else{
                    left=mid+1;
                }
            }
        }
        return -1;
    }
    int getlowernum(vector<int>& nums, int target){
        int left=0,right=nums.size()-1,mid=0,ans=0;
        while(left<=right){
           // cout<<"left:"<<left<<" "<<"right:"<<right<<endl;
            mid=left+(right-left)/2;
           // cout<<"mid:"<<mid<<endl;
            ans=nums[mid];
            if(ans>target){
                right=mid-1;
            }else if(ans<target){
                left=mid+1;
            }else{
                if(mid==0 || nums[mid-1]!=target){
                    return mid;
                }else{
                    right=mid-1;
                }
            }
        }
        return -1;
    }
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.size()==0){
            return vector<int>{-1,-1};
        }
        int left=getlowernum(nums,target);
        int right=getuppernum(nums,target);
        return vector<int>{left,right};
    }
};

2.3Leetcode81

2.3.1题目描述

已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。
给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

2.3.2输入输出格式

输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true

2.3.3代码

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

2.4Leetcode154

2.4.1题目描述

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]
注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。
给你一个可能存在 重复 元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素

2.4.2输入输出格式

输入：nums = [2,2,2,0,1]
输出：0

2.4.3代码

class Solution {
public:
    int findMin(vector<int>& nums) {
        int start=0;
        int end=nums.size()-1;
        int mid=0;
        while(start<=end){
            mid=start+(end-start)/2;
            if(nums[mid]<nums[end]){
                end=mid;
            }else if(nums[mid]>nums[end]){
                start=mid+1;
            }else{
                end--;
            }
        }
        return nums[start];
    }
};

2.5Leetcode540

2.5.1题目描述

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

2.5.2输入输出格式

输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2

2.5.3代码

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int start=0;
        int end=nums.size()-1;
        int mid=0;
        int ans=0;
        if(nums.size()==1){
            return nums[0];
        }
        if(nums[start]!=nums[start+1]){
            return nums[start];
        }
        if(nums[end]!=nums[end-1]){
            return nums[end];
        }
        while(start<=end){
            mid=start+(end-start)/2;
            if(nums[mid]!=nums[mid-1] && nums[mid]!=nums[mid+1]){
                return nums[mid];
            }else{
                if(nums[mid]==nums[mid-1]){
                    if((mid-start)%2==1){
                        start=mid+1;
                    }else{
                        end=mid;
                    }
                }else if(nums[mid]==nums[mid+1]){
                    if((end-mid)%2==1){
                        end=mid-1;
                    }else{
                        start=mid;
                    }
                }
            }
        }
        return nums[start];
    }
};