二分查找刷题

int search(vector<int>& nums, int target) {
        // write code here
        int i=0;int j=nums.size()-1;
        while(i<=j){
            int mid=(i+j)/2;
            if(nums[mid]>target){
                j=mid-1;
            }
            else if(nums[mid]<target){
                i=mid+1;
            }
            else{
                return mid;
            }
        }
        return -1;
    }

 

int searchInsert(vector<int>& nums, int target) {
        int i=0;int j=nums.size()-1;
        while(i<=j){
            int mid=(i+j)/2;
            if(nums[mid]>target){
                j=mid-1;
            }
            else if(nums[mid]<target){
                i=mid+1;
            }
            else{
                return mid;
            }
        }
        //例如1，3时找元素2，首先i，j会指向3，然后j指向1，跳出循环，所以返回i
        return i;
    }

 

vector<int> searchRange(vector<int>& nums, int target) {
        int i=0;int j=nums.size()-1;
        //先找右边界，方法为与目标值相等时移动左指针，右指针不动，使左指针逐步逼近右指针
        //如果0，0，0，0，1的话，最后一定是左指针0，右指针1.然后左指针也1，右指针0
        //0，0，0，0，0的情况，右指针不动，左指针会移出去
        while(i<=j){
            int mid=(i+j)/2;
            if(nums[mid]>target){
                j=mid-1;
            }
            else if(nums[mid]<target){
                i=mid+1;
            }
            else{
                i=mid+1;
            }
        }
        int right=j;
        //同理左边界
        i=0;j=nums.size()-1;
        while(i<=j){
            int mid=(i+j)/2;
            if(nums[mid]>target){
                j=mid-1;
            }
            else if(nums[mid]<target){
                i=mid+1;
            }
            else{
                j=mid-1;
            }
        }
        int left=i;
        //如果左右边界不重合
        if(right-left+1>0)return {left,right};
        else{
            return {-1,-1};
        }
    }

 

int findPeakElement(vector<int>& nums) {
        int left = 0;
        int right = nums.size() - 1;
        //二分法
        while(left < right){ //如果left==right了，那么此时一定是波峰了，不需要判断了
            int mid = (left + right) / 2;
            //右边是往下，不一定有坡峰
            if(nums[mid] > nums[mid + 1])
                right = mid;
            //右边是往上，一定能找到波峰
            else
                left = mid + 1;
        }
        //其中一个波峰
        return right; 
    }

 

int ret=0;
    void mergesort(vector<int>& data, vector<int>& tmp, int m, int n) {
        if (m == n)return;
        int k = (m + n) / 2;
        mergesort(data, tmp, m, k);
        mergesort(data, tmp, k + 1, n);
        merge_(data, tmp, m, k, n);
    }
    void merge_( vector<int>& data, vector<int>& tmp, int m, int k, int n) {
        int i = m;
        int j = k + 1;
        int t = 0;
        while (i != k + 1 && j != n + 1) {
            if (data[i] > data[j]) {
                tmp[t++] = data[j++];
                ret+=k-i+1;ret=ret%1000000007;
            } else {
                tmp[t++] = data[i++];
            }
        }
        while (i <= k) {
            tmp[t++] = data[i++];
        }
        while (j <= n) {
            tmp[t++] = data[j++];
        }
        for (int b = 0, i = m; i <= n; i++, b++) {
            data[i] = tmp[b];
        }
    }
    int InversePairs(vector<int> data) {
        vector<int>tmp(data.size(),0);
    mergesort(data, tmp, 0, data.size() - 1);
    return ret;
    }

 

int minNumberInRotateArray(vector<int> rotateArray) {
        int i=0;int j=rotateArray.size()-1;int mid=0;
        while(i<=j){
            mid=(i+j)/2;
            if(rotateArray[mid]<rotateArray[j]){//以j的值为比较，因为二分需要判断的值相同
                j=mid;//寻找到小的了，收缩区间，但不能为mid-1，因为不能确保mid不是最小的
            }
            else if(rotateArray[mid]>rotateArray[j]){
                i=mid+1;
            }
            else{
                j--;//如果相等了则收缩区间，收缩区间方式如果为j=mid的话跳不出循环
            }
        }
        return rotateArray[i];//最后肯定是j--后跳出循环，此时i是最小数字
    }

 

 int compare(string version1, string version2) {
        int n1 = version1.size();
        int n2 = version2.size();
        int i = 0, j = 0;
        //直到某个字符串结束
        while(i < n1 || j < n2){
            long long num1 = 0;
            //从下一个点前截取数字
            while(i < n1 && version1[i] != '.'){ 
                num1 = num1 * 10 + (version1[i] - '0');
                i++;
            }
            //version1[i] - '0'可以将字符型数字转换成整型数字，因为字符型数字和整型数字在ASCII码中是有对应关系的，'0'的ASCII码值是48，'1'的ASCII码值是49，以此类推，所以version1[i] - '0'实际上就是将字符型数字对应的ASCII码值减去'0'的ASCII码值得到整型数字。
            //跳过点
            i++; 
            long long num2 = 0;
            //从下一个点前截取数字
            while(j < n2 && version2[j] != '.'){ 
                num2 = num2 * 10 + (version2[j] - '0');
                j++;
            }
            //跳过点
            j++; 
            //比较数字大小
            if(num1 > num2) 
                return 1;
            if(num1 < num2)
                return -1;
        }
        //版本号相同
        return 0; 
    }