算法整理-二分查找和排序

Posted 2022-02-09 cookcoder-mr

1.  二分查找

   (1) 有序数组查找插入位置：  主要是终止条件的判断，如果查找不到需要被范围的插入位置为begin

public:
    int searchInsert(vector<int>& nums, int target) 
        int len = nums.size();
        return binarySearch(nums, target, 0, len-1);
    
private:
    int binarySearch(vector<int>& nums, int target, int begin, int end) 
         if (begin > end) 
             return begin;
         
         int mid = (begin + end) / 2;
         if (target == nums[mid]) return mid;
         else if (target < nums[mid]) 
         
             return binarySearch(nums, target, begin, mid - 1);
         else 
         
             return binarySearch(nums, target, mid+1, end);

    

  (2) rotated array 寻找最小值

      第一种情况： 不包含重复数字， 

class Solution 
public:
    int findMin(vector<int>& nums) 
        int len = nums.size();
        return bsearch(nums, 0, len-1);        
    
private:
   int bsearch(const vector<int> nums, int s, int e)
       if (s >= e) return nums[s];
       int mid = (s + e) / 2;
       // 在左侧数组上
       if (nums[mid] > nums[e]) return bsearch(nums, mid+1, e);
       // 在右侧数组上
       else return bsearch(nums, s, mid);
   
;

   （3） rotated array 寻找某个值，允许重复：

         分成三种情况，（1） 是递增数组 （2） num[s] == num[mid] = nums[e]    用O（n)的时间顺序查找

                              （3）两段数组的类型， 二分查找，先判断mid是在哪一段数组上

class Solution 
public:
    bool search(vector<int>& nums, int target) 
        int len = nums.size();
        if(len == 0) return false;
        return bsearch(nums, target, 0, len - 1);
    
private:
    bool bsearch(const vector<int>& nums, int target, int s, int e)
        if ( s > e) 
            return false;
        
        if (cornercase(nums, s, e))
           return asearch(nums, target, s, e);
         

        if (nums[s] >= nums[e])
             int mid = (s + e) / 2;
             if (nums[mid] == target) return true;
             if (nums[mid] >= nums[s])  // mid在左边序列
                 // target比mid大一定在右边序列
                 if (target > nums[mid]) return bsearch(nums, target, mid+1, e);
                 // t比mid小，当t大于end则一定在左侧
                 else if (target > nums[e]) return bsearch(nums, target, s, mid-1);
                 else if (target < nums[e]) return bsearch(nums, target, mid+1, e);
                 else return true;
             
             if (nums[mid] < nums[s]) // mid在右边序列
                 if (target < nums[mid]) return bsearch(nums, target, s, mid-1);
                 else if(target > nums[e]) return bsearch(nums, target, s, mid-1);
                 else if(target < nums[e]) return bsearch(nums, target, mid+1, e);
                 else return true;
             
        
       return false;
    

    bool cornercase(const vector<int>& nums, int s, int e)
        int mid = (s + e) / 2;
        if (nums[s] == nums[e] && nums[mid] == nums[s])
            return true;
         
        if (nums[s] <= nums[e] && nums[mid] >= nums[s])
            return true;
        
        return false;
    

    bool asearch(const vector<int>& nums, int target, int s, int e)
        for (int i = s; i <=e; i++)
               if (nums[i] == target) return true;
        
        return false;
    
;