算法基础/二分查找

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

题目描述：

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例：

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

示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

解答描述:

该题要用O（logn）的时间复杂度找到给定目标值在数组中的开始位置和结束位置。

首先，对于有序数组的logn的查找，考虑二分法；

其次，先用二分法找到大于等于目标值在数组中出现的第一个位置index1；

接着，继续用二分法找到大于等于目标值+1在数组中出现的第一个位置index2；

最后，如果index1不等于n，且index1位置的数刚好为目标值，那么它就是开始位置，那么结束位置就是index2-1。

注意：在有序数组中查找大于等于x的第一个位置的二分代码和普通的有点不一样，当nums[mid]>=target时，r=mid-1,且最终返回l所在下标。

代码：

class Solution {
public:
    //找到大于等于target的第一个位置
    int search_first(vector<int>& nums,int target)
    {
        int n=nums.size();
        int l=0;
        int r=n-1;
        int index=-1;
        while(l<=r)
        {
            int mid=(l+r)/2;
            if(nums[mid]>=target)
            {
                r=mid-1;
            }
            else
            {
                l=mid+1;
            }
        }
        return l;
    }
    vector<int> searchRange(vector<int>& nums, int target) {
        int n=nums.size();
        vector<int> ans(1*2);
        ans[0]=-1;
        ans[1]=-1;
        
        if(n==0)
        {
            return ans;
        }
        int min_index=search_first(nums,target);
        int max_index=search_first(nums,target+1);
        printf("%d %d ",min_index,max_index);
        if(min_index==n || nums[min_index]!=target )//注意这里的顺序，不然容易越界
        {
            return ans;
        }
        else
        {
            ans[0]=min_index;
            ans[1]=max_index-1;
        }
        
        return ans;
    }
};

2.33. 搜索旋转排序数组

题目描述：

整数数组 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,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

示例：

示例 1：
输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：
输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：
输入：nums = [1], target = 0
输出：-1

解答描述:

要在旋转后的数组中搜索目标值，和传统的有序数组的二分查找有区别的是，旋转后的数组的有序是分段的。

基本思想是：将数组一分为二，其中一定有一个是有序的，另一个可能是有序，也能是部分有序。 此时有序部分用二分法查找。无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样循环。

具体地，先找到中间元素nums[mid]，如果等于目标值target，那么直接返回mid即可。

否则，如果左边有序，且目标值在左边范围内，那么在左边二分查找，如果不在左边范围内，那么就去右边查找，如果右边有序，同理。

注意：当数组只有一个元素时，只需要看它是否等于目标值即可。

代码：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        /*将数组一分为二，其中一定有一个是有序的，另一个可能是有序，也能是部分有序。 此时有序部分用二分法查找。无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样循环.*/
        int n=nums.size();
        if(n==1)
        {
            return nums[0]==target?0:-1;
        }
        int l=0;
        int r=n-1;
        int mid=-1;
        while(l<=r)//也要注意这里的等号
        {
            mid=(l+r)/2;
            if(nums[mid]==target)
            {
                return mid;
            }
            if(nums[l]<=nums[mid])//说明左半部分是有序的 注意这里的等号，为了左半部分只有一个元素的情况
            {
                if(target>=nums[l] && target<=nums[mid])//要查找的值在左半部分值域内，在左半部分找
                {
                    r=mid;
                }
                else//否则，在右半部分查找
                {
                    l=mid+1;
                }
            }
            else if(nums[mid+1]<=nums[r])//右半部分有序
            {
                if(target>=nums[mid+1] && target<=nums[r])//要查找的值在右半部分值域内，在右半部分找
                {
                    l=mid+1;
                }
                else//否则，在左半部分查找
                {
                    r=mid;
                }
            }
        }
        return -1;
    }
};

3.74. 搜索二维矩阵

题目描述：

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

示例：

 

解答描述:

因为每一行都是有序的，且逐行递增，所以只需要对每一行，先判断目标值是不是在这一行的范围内，如果在的话进行二分查找，不在的话继续下一行的判断即可。

代码：

class Solution {
public:
    int binary_search(vector<int> nums, int target)
    {
        int n=nums.size();
        int l=0;
        int r=n-1;
        int mid=-1;
        while(l<=r)//注意这里的等号，为了一行数组只有一个数的情况
        {
            int mid=(l+r)/2;
            if(nums[mid]<target)
            {
                l=mid+1;
            }
            else if(nums[mid]>target)
            {
                r=mid-1;
            }
            else
            {
                return mid;
            }
        }
        return -1;
    }
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int rows=matrix.size();
        int cols=matrix[0].size();
        for(int i=0;i<rows;i++)//在每一层执行二分查找
        {
            if(target>=matrix[i][0] && target<=matrix[i][cols-1])//在该层范围内
            {
                int ans=binary_search(matrix[i],target);
                printf("ans: %d",ans);
                if(ans==-1)//该层二分查找没有找到
                {
                    continue;
                }
                else
                {
                    return true;
                }
            }
        }
        return false;
    }
};