LeetCode刷题总结---二分查找

LeetCode 刷题总结(二分查找)

二分主要是形成自己的代码风格就可以了。常用两种风格(现在偏向于风格一实现了)：

LeetCode35. 搜索插入位置：
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

这个实际上就是手动实现lower_bound()函数(返回值为：在不破坏排序状态的原则下，可插入value的第一个位置)。
注：upper_bound()是返回可插入value的后一个位置。

风格一：

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

风格二：

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

34. 在排序数组中查找元素的第一个和最后一个位置。这道题相比较lower_bound()就有一丢丢不同了。因为不存在的时候是要返回-1,而上面的是返回0。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        std::vector<int> v{
            left_bound(nums,target),
            right_bound(nums,target)
        };
        return v;
    }

    int left_bound(std::vector<int> &nums,int target){

        int left = 0,right = nums.size()-1;
        while(left <= right){
            int  mid = left + right >> 1;
            if(nums[mid] == target){
                if(mid == 0 || nums[mid-1] < target )return mid;//判断是否为第一个出现的
                right = mid - 1;
            }
            else if(nums[mid] < target)left = mid+1;
            else right = mid-1;

        }
        return -1;
    }

    int right_bound(std::vector<int> &nums,int target){
        int left = 0,right = nums.size()-1;
        while(left <= right){
            int mid = left + right >> 1;
            if(nums[mid] == target){
                if(mid == nums.size()-1 || nums[mid+1] > target )
                    return mid;
                left = mid+1;
            }
            else if(nums[mid] < target)left = mid+1;
            else right = mid-1;
        }
        return -1;
    }
};

69. x 的平方根直接二分写就写了.

class Solution {
public:
    int mySqrt(int x) {
        int l = 0,r = x/2+1;
        while(l<=r){
            long long mid = l+r>>1;
            if(mid*mid<=x && (mid+1)*(mid+1) >x)return mid;
            else if(x < mid*mid)r = mid-1;
            else l = mid+1;
        }
        return 0;
    }
};

还有一些假二维的：
74. 搜索二维矩阵，这个是假二维了。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int n = matrix.size();
        if(!n)return false;
        int m = matrix[0].size();
        if(!m)return false;
        int l = 0,r = m*n-1;
        
        while(l<=r){
            int mid = l+r>>1;
            if(matrix[mid/m][mid%m] == target)return true;
            else if(matrix[mid/m][mid%m] < target)l = mid+1;
            else r = mid-1;
        }
        return false;
    }
};

240. 搜索二维矩阵 II这个差不多二维，根据规律卡右上角。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        
        int n = matrix.size();
        if(!n)return false;
        int m = matrix[0].size();
        if(!m)return false;
        
        int i = 0, j = m-1;
        while(i<n && j>=0){
            if(matrix[i][j] == target)return true;
            else if(matrix[i][j] > target)j--;
            else i++;
        }
        return false;
    }
};

154. 寻找旋转排序数组中的最小值 II

class Solution {
public:
    int findMin(vector<int>& nums) {
        int n = nums.size();
        
        int l = 0,r = n-1;
        while(l+1 < r)
        {
            int mid = l+r>>1;
            if(nums[mid] < nums[r])  //mid在右边
                r = mid;
            else if(nums[mid] > nums[r])
                l = mid;
            else 
                r = r - 1;
        }
        return min(nums[l],nums[r]);
    }
};

还有一些看起来要有点变换的二分：

33. 搜索旋转排序数组
画图很容易分析二分：

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

              if(nums[left] <= nums[mid]){//左边有序(等于对应2个元素翻转)
                  if(target < nums[mid] && target >= nums[left])//也要有=
                      right = mid-1;//缩小
                  else
                      left = mid+1;
              }
              else{//右边有序
                  if(target > nums[mid] && target <= nums[right])
                      left = mid+1;
                  else right = mid-1;
              }
              
          }      
          return -1;
    }
};

81. 搜索旋转排序数组 II:
这个是上面的强化版，可以有重复数字了：1 3 3 3 3 3.旋转之后有可能是3 1 3 3 3.这时候a[l]和a[mid]都是3了，所以二分的方向就没了，就需要一步一步地走。上题中两者相同是1 2旋转成 2 1这种情况。没影响。

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

              if(nums[left] < nums[mid]){
                  if(target < nums[mid] && target >= nums[left])
                      right = mid-1;//缩小
                  else
                      left = mid+1;
              }
              else if(nums[left] > nums[mid]){
                  if(target > nums[mid] && target <= nums[right])
                      left = mid+1;
                  else right = mid-1;
              }
            else left++;//相等的一个一个的走吧。
              
          }      
          return false;

    }
};

来看道逼格高点的二分：
4. 寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

这是个经典的Top K 问题，求两个有序数组的第K个数是多少。

用到Manacher构造奇数长度的办法。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
    int m = nums1.size(),n = nums2.size();
    if(m<n)return findMedianSortedArrays(nums2,nums1);//第二个是小点的数组，为构造虚拟数组方便。
    if(n == 0)return ( (double)nums1[(m-1)/2] + (double)nums1[m/2]) / 2.0;
    int l = 0,r = n<<1;//此时小数组长度为2*n+1
    while(l <= r)
    {
        int mid2 = (l+r)>>1;
        int mid1 = m+n-mid2;//mid1+mid2 = m+n;
        double l1 = mid1==0?INT_MIN:nums1[(mid1-1)/2];//映射回去
        double l2 = mid2==0?INT_MIN:nums2[(mid2-1)/2];
        double r1 = mid1==m*2? INT_MAX: nums1[mid1/2];
        double r2 = mid2==n*2? INT_MAX: nums2[mid2/2];
          if(l1 > r2)l = mid2+1;//2小，让2变大。
          else if(l2 > r1)r = mid2-1;//2大
          else return (max(l1,l2) + min(r1,r2)) / 2;
    }
    return -1;
    }
};