stl_algo_图解lower_bound & upper_bound算法及LeetCode例题

stl_algo_图解lower_bound & upper_bound算法

1.1、lower_bound的作用

  lower_bound就是二分查找的一种左边界版本，他返回一个迭代器。在排序好的[first, last)区间中寻找value,如果找到这些元素（可能有多个重复的），就返回指向第一个元素的迭代器;如果没找到，那么就返回指向该value的值在不破坏排序条件下应该在的位置的迭代器，例子如下：

lb1 = lower_bound(first, last, 2);
lb2 = lower_bound(first, last, 3);
lb3 = lower_bound(first, last, 6);

如图所示：

1.2、lower_bound的实现

  知道了lower_bound的作用之后，在跟着代码来看stl中的实现。

  1.2.1 forward_iterator（前向迭代器版本）lower_bound。

template<class ForwardIterator, class T, class Distance>
ForwardIterator my_lower_bound(ForwardIterator first, ForwardIterator last, \
    const T& value, Distance*, forward_iterator_tag) {
    
    Distance len = 0;
    len = distance(first, last);//求区间长度len
    Distance half;
    ForwardIterator middle;

    while (len > 0) {
        half = len >> 1; //除以2
        middle = first;
        advance(middle, half); //让middle指向中间位置
        if (*middle < value) {//如果这个值小于value
            first = middle;
            ++first;           //令first指向middle的下一个位置
            len = len - half - 1; //调整len,回头测试循环的结束条件
        }
        else {
            len = half;//调整len, 回头测试循环的结束条件
        }
    }
    
    return first;
}

  1.2.2 random_access_iterator（随机迭代器版本）lower_bound。

template<class RandomAccessIterator, class T, class Distance>
RandomAccessIterator my_lower_bound(RandomAccessIterator first, RandomAccessIterator last, \
    const T& value, Distance*, random_access_iterator_tag) {

    Distance len = last - first;
    Distance half;
    RandomAccessIterator middle;

    while (len > 0) {
        half = len >> 1;
        middle = first + half;

        if (*middle < value) {//如果这个值小于value
            first = middle + 1; //令first指向middle的下一个位置
            len = len - half - 1; //调整len,回头测试循环的结束条件
        }
        else {
            len = half;
        }
    }

    return first;
}

2.1、upper_bound的作用

  和lower_upper类似，upper_bound是二分查找的一种右边界版本，他返回一个迭代器，如果找到了该元素，他就返回指向该元素下一个位置的迭代器，也就是返回在不破坏排序的情况下，插入value的最后位置。如下图所示：

ub1 = upper_bound(first, last, 2);
ub2 = upper_bound(first, last, 3);
ub3 = upper_bound(first, last, 6);

2.2、upper_bound的实现

  2.2.1 forward_iterator（前向迭代器版本）upper_bound

template<class ForwardIterator, class T, class Distance>
ForwardIterator my_upper_bound(ForwardIterator first, ForwardIterator last, \
    const T& value, Distance*, forward_iterator_tag) {

    Distance len = 0;
    len = distance(first, last);//求区间长度len
    Distance half;
    ForwardIterator middle;

    while (len > 0) {
        half = len >> 1; //除以2
        middle = first;
        advance(middle, half); //让middle指向中间位置

        if (value < *middle) {//如果这个值小于value
            len = half;
        }
        else {
            first = middle;
            ++first;           //令first指向middle的下一个位置
            len = len - half - 1; //调整len,回头测试循环的结束条件
            
        }
    }
    return first;
}

  2.2.2 random_access_iterator（随机迭代器版本）upper_bound。

template<class RandomAccessIterator, class T, class Distance>
RandomAccessIterator my_upper_bound(RandomAccessIterator first, RandomAccessIterator last, \
    const T& value, Distance*, random_access_iterator_tag) {

    Distance len = last - first;
    Distance half;
    RandomAccessIterator middle;

    while (len > 0) {
        half = len >> 1;
        middle = first + half;

        if (value < *middle) {//如果这个值小于value
            len = half;
        }
        else {
            first = middle + 1; //令first指向middle的下一个位置
            len = len - half - 1; //调整len,回头测试循环的结束条件
        }
    }

    return first;
}

3.例题讲解

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

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

你的算法时间复杂度必须是 O(log n) 级别。

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int len = nums.size();
        if(len == 0) return vector<int>{-1,-1};

        int lb = my_lower_bound(nums, target);
        int ub = my_upper_bound(nums, target);

        if(lb == len || nums[lb] != target){
            return vector<int>{-1,-1};
        }

        return vector<int>{lb,ub - 1};
    }
    
    int my_lower_bound(vector<int>& nums, int target){
        int l = 0, r = nums.size();

        while(l < r){
            int mid = l + (r - l) / 2;

            if(nums[mid] >= target){
                r = mid;
            }else{
                l = mid + 1;
            }
        }
        return l;
    }

    int my_upper_bound(vector<int>& nums, int target){
        int l = 0, r = nums.size();

        while(l < r){
            int mid = l + (r - l) / 2;

            if(nums[mid] <= target){
                l = mid + 1;
            }else{
                r = mid;
            }
        }
        return l;
    }
};