LeetCode || Search for a Range

最新推荐文章于 2025-08-13 16:21:27 发布

原创最新推荐文章于 2025-08-13 16:21:27 发布 · 353 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #Merge #二分查找 #算法 #搜索

LeetCode 专栏收录该内容

107 篇文章

订阅专栏

本文探讨了在有序数组中使用二分查找算法确定目标值出现的起始和结束位置的方法。介绍了三种实现方式：顺序搜索改进版、从后往前搜索优化及递归方法，并对比了各自的执行效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

使用二分查找算法，但是遇到求解范围的时候遇到瓶颈。先用顺序搜索求解。

时间：20ms。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int i = 0, j = nums.size()-1;
        int mid = (i+j)/2;
        
        vector<int> range;
        range.push_back(-1);
        range.push_back(-1);
        while(i <= j)
        {
            if(nums[mid] == target)//
            {
                range[0] = i;
                range[1] = j;
                break;
            }
            else if(nums[mid] > target)
            {
                j = mid-1;
                mid = (i + j)/2;
            }
            else
            {
                i = mid+1;
                mid = (i+j)/2;
            }
        }
        
        
        while(range[0] < nums.size() && nums[range[0]] != target)
            range[0]++;
        while(range[1] < nums.size() && nums[range[1]] != target)
            range[1]--;

        return range;
    }
};

从后往前搜索，时间提高，变为12ms、

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int i = 0, j = nums.size()-1;
        int mid = (i+j)/2;
        
        vector<int> range;
        range.push_back(-1);
        range.push_back(-1);
        while(i <= j)
        {
            if(nums[mid] == target)//
            {
                //从i到mid搜索第一个target
                int tmp = mid -1;
                while(tmp >= 0 && nums[tmp] == target)
                    tmp--;
                    
                range[0] = tmp+1;
                
                //从mid到j搜索最后一个target
                tmp = mid + 1;
                while(tmp < nums.size() && nums[tmp] == target)
                    tmp++;
                range[1] = tmp-1;;
                break;
            }
            else if(nums[mid] > target)
            {
                j = mid-1;
                mid = (i + j)/2;
            }
            else
            {
                i = mid+1;
                mid = (i+j)/2;
            }
        }

        return range;
    }
};

递归方法实现二分搜索；耗时12ms。

class Solution {
public:
    vector<int> searchRangeCore(vector<int>& nums, int s, int e, int target)
    {
        int mid = (s+e)/2;
        
        vector<int> range;
        range.push_back(-1);
        range.push_back(-1);
            
        if(nums[s] == target && nums[e] == target)
        {
            range[0] = s;
            range[1] = e;
            return range;
        }
        
        while(s <= e)
        {
            if(nums[mid] == target)//
            {
                //从s到mid搜索第一个target
                vector<int> r1 = searchRangeCore(nums, s, mid, target);
                
                //从mid到e搜索最后一个target
                vector<int> r2 = searchRangeCore(nums, mid+1, e, target);
                
                //联合r1和r2
                if(r1 == range)
                    range = r2;
                if(r2 == range)
                    range = r1;
                if(r1[1] == r2[0]-1)
                {
                    range[0] = r1[0];
                    range[1] = r2[1];
                }
                break;
            }
            else if(nums[mid] > target)
            {
                e = mid-1;
                mid = (s + e)/2;
            }
            else
            {
                s = mid+1;
                mid = (s+e)/2;
            }
        }

        return range;
    }
    vector<int> searchRange(vector<int>& nums, int target) {
        return searchRangeCore(nums, 0, nums.size()-1, target);
    }
};