20210408:力扣(二分查找法的两种写法以及变体题目)

写在前面

1. 关于二分查找，真的是一个非常实用的查找算法，主要有两种写法，今天在总结时再次碰到，再次整理，方便后续查看复习。

2. 这两种写法分别是递归式写法和循环式写法。

3. 递归式写法

// 从已排序数组sorted_arr中寻找target，找到则返回true
bool binary_search(vector<int> & sorted_arr,int begin,int end,int target) {
	if (begin > end) {
		return false;
	}	
	int mid = (begin + mid) / 2;
	if (target == sorted_arr[mid]) {
		return true;
	} else if (target > sorted_arr[mid]) {
		return binary_search(sorted_arr,mid + 1,end,target);
	} else {
		return binary_search(sorted_arr,begin,mid - 1,target);
	}
}

1. 循环式写法

// 从已排序数组sorted_arr中寻找target，找到则返回true
int binary_search(vector<int>& sorted_arr, int target) {
        int begin = 0;
        int end = sorted_arr.size() - 1;
        while (begin <= end) {
            int mid = (end + begin) / 2;
            if (target == sorted_arr[mid]) { 
                return true;
            } else if (target < sorted_arr[mid]) {
                end = mid - 1;
            } else {
                begin = mid + 1;
            }
        }
        return false;
    }

那么接下来从两道力扣的经典题目来对二分查找进行一个更深入的理解

题目

1. 35. 搜索插入位置
       
2. 34. 在排序数组中查找元素的第一个和最后一个位置

思路与算法

1. 35. 搜索插入位置
       解题思路：点明我个人比较习惯使用的为第二种循环式写法，本题为简单，与常规二分的唯一区别为：找得到直接返回索引，找不到则返回应该插入的位置的索引，也就是在判断更新二分的区间时需要加判断前一个数比当前数小（因为题目给定了元素不重复），这类数组类的题目要单独分析两个边界的特殊情况的处理，也就是到达边界的时候直接返回即可。
2. 34. 在排序数组中查找元素的第一个和最后一个位置
       解题思路：依旧判断我们需要增加的更新二分区间的条件：第一，需要找到左边界，那么判断条件类似上一题，需要前一个值小于当前值，且注意如果已经是左边界就返回，同理，右边界也是一样。那么本题也就结束了，第二题附上cpp的循环写法以及java的递归写法。思路完全一致。

代码实现

1. 35. 搜索插入位置

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

2. 34. 在排序数组中查找元素的第一个和最后一个位置
       cpp循环写法：

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

private:
    int left_bound(vector<int>& nums, int target) {
        int begin = 0;
        int end = nums.size() - 1;
        while (begin <= end) {
            int mid = ( begin + end ) / 2;
            if (target == nums[mid]) { 
                if (mid == 0 || nums[mid - 1] < target) {
                    return mid;
                }
                end = mid - 1;
            } else if (target > nums[mid]) {
                begin = mid + 1;
            } else if (target < nums[mid]) {
                end = mid - 1;
            }
        }
        return -1;
    }
private:
    int right_bound(vector<int>& nums, int target) {
        int begin = 0;
        int end = nums.size() - 1;
        while (begin <= end) {
            int mid = ( begin + end ) / 2;
            if (target == nums[mid]) { 
                if (mid + 1 == nums.size() || nums[mid + 1] > target) {
                    return mid;
                }
                begin = mid + 1;
            } else if (target > nums[mid]) {
                begin = mid + 1;
            } else if (target < nums[mid]) {
                end = mid - 1;
            }
        }
        return -1;
    }
};

Java递归写法：

class Solution {
    int begin = Integer.MAX_VALUE;
    int end = Integer.MIN_VALUE;

    public int[] searchRange(int[] nums, int target) {
        recursive(nums, target, 0, nums.length-1);
        if(begin == Integer.MAX_VALUE || end == Integer.MIN_VALUE)
            return new int[]{-1,-1};
        return new int[]{begin, end};
    }

    public void recursive(int[] nums, int target ,int l, int r){
        if(l > r) 
            return;
        int mid = (l+r)/2;
        if(target == nums[mid]){
            if(mid < begin) 
                begin = mid;
            if(mid > end) 
                end = mid;
            recursive(nums, target, mid + 1, r);
            recursive(nums, target, l, mid -1);
        } else if (target > nums[mid]) {
            recursive(nums, target, mid + 1, r);
        } else {
            recursive(nums, target, l, mid -1);
        }
    }
}

写在最后

1. 保持节奏，稳步前进！