二分查找

1. x的平方根   难度：easy    Leetcode题号：69

题目描述：

思路：

由于本人太菜，用不了牛顿迭代法（数学大佬们可以看看），故使用二分查找做的这道题，二分查找的初试左端点很好判断，取0就可以，初试右端点需要一定的考虑，我们可以解一个不等式：(a/2)^2>=a，解得a<=0或a>=4，故可以得出结论：大于等于4的整数的平方根都比它的二分之一要小，而本题中0，1，2，3的平方根分别是0，1，1，1，故可以判断一下x的值，只有当x>=4时才需要进行二分查找

代码：

class Solution {
public:
    int mySqrt(int x) {
        int a[4] = {0, 1, 1, 1};
        if(x == 0 || x == 1 || x == 2 || x == 3){
            return a[x];
        }
        int l = 0, h = x / 2;
        while(l <= h){
            int mid = l + (h - l) / 2;
            int sqrt = x / mid;
            if(sqrt == mid){
                return mid;
            } else if(sqrt > mid){
                l = mid + 1;
            } else{
                h = mid - 1;
            }
        }
        return h; //由于退出循环时一定是h<l，故向下取整应返回h
    }
};

 

2. 寻找比目标字母大的最小字母   难度：easy    Leetcode题号：744

题目描述：

思路：

很清晰，二分查找，注意一下判断的条件即可

代码如下：

class Solution {
public:
    char nextGreatestLetter(vector<char>& letters, char target) {
        int l = 0, r = letters.size() - 1;
        while( l <= r){
            int mid = l + (r - l) / 2;
            if(letters[mid] > target){
                r = mid - 1;
            } else{
                l = mid + 1;
            }
        }
        return l < letters.size() ? letters[l] : letters[0];
    }
};

 

3. 有序数组中的单一元素   难度：medium   Leetcode题号：540

题目描述：

思路：由于是有序数组，且除一个数只出现一次外，其他的数都出现了两次，所以数组元素的个数一定为奇数，采用二分查找时，若分割元素nums[mid]不是目标数字，则其会出现两次（可能和它左边的元素相等，也可能和它右边的元素相等），根据这个特性，可以将数组进一步划分成一个含有奇数个元素的数组和一个含有偶数个元素的数组，具体的划分分为四种情况：

（1）. nums[mid]==nums[mid+1]  且 r-mid为偶数，此时划分的两个半区如下图所示

显然，要查找的数在右半区，故此时应令l = mid + 2，继续在右半区查找

（2）. nums[mid] == nums[mid+1] 且 r-mid为奇数，此时划分的两个半区如下图所示：

显然，要查找的数在左半区，故此时应令 r = mid-1 ，继续在左半区查找

（3）.nums[mid] == nums[mid-1] 且 r-mid为偶数，此时划分的两个半区如下图所示：

 

显然，要查找的数在左半区，故此时应令 r = mid-2 ，继续在左半区查找

（4） .nums[mid] == nums[mid-1]且r-mid为奇数，此时划分的两个半区如下图所示：

显然，要查找的数在右半区，故此时应令l = mid + 1，继续在右半区查找

重复这样划分下去，最终只会剩下一个元素，此时nums[l]就是要找的数

代码如下：

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        while(l < r){
            int mid = l + (r-l)/2;
            bool flag = (r-mid)%2==0; //看判断划分后的两个半区元素个数的奇偶性
            if(nums[mid] == nums[mid+1]){
                if(flag){
                    l = mid + 2;
                } else{
                    r = mid - 1;
                }
            } else if(nums[mid] == nums[mid-1]){
                if(flag){
                    r = mid - 2;
                } else{
                    l = mid + 1;
                }
            } else{
                return nums[mid];
            }
        }
        return nums[l];
    }
};

 

4. 第一个错误的版本   难度:easy  Leetcode题号：278

题目描述：

思路：

此题和上述寻找比目标字母大的第一个字母很类似，思路也是一样的

代码如下：

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int l = 1, r = n;
        while(l <= r){
            int mid = l + (r - l) / 2;
            if(isBadVersion(mid)){
                r = mid - 1;
            } else{
                l = mid + 1;
            }
        }
        return l;
    }
};

 

5. 寻找旋转排序数组中的最小值  难度：medium  Leetcode题号：153

题目描述：

代码如下：

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

 

6. 在排序数组中查找元素的第一个位置和最后一个位置  难度：medium  Leetcode题号：34

题目描述：

思路：找到target之后，使用双指针找它之前和它之后的元素，直到指针指向的元素不等于target为止

代码如下：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        vector<int> ans;
        while(l <= r){
            int mid = l + (r - l) / 2;
            if(nums[mid] > target){
                r = mid - 1;
            } else if(nums[mid] < target){
                l = mid + 1;
            } else if(nums[mid] == target){
                int i = mid, j = mid; //双指针寻找
                while(i >= 0 && nums[i] == target){
                    i--;
                }
                ans.push_back(i+1);
                while(j <= nums.size()-1 && nums[j] == target){
                    j++;
                }
                ans.push_back(j-1);
                return ans;
            }
        }
        if(l == r + 1){    //target不存在于数组中的情况
            ans.push_back(-1);
            ans.push_back(-1);
        }
        return ans;
    }
};