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

最新推荐文章于 2023-03-29 20:55:41 发布

打盹码农

最新推荐文章于 2023-03-29 20:55:41 发布

阅读量132

点赞数

分类专栏： LeetCode 文章标签：算法 leetcode 排序算法二分

本文链接：https://blog.csdn.net/AHASAN/article/details/116157434

版权

LeetCode 专栏收录该内容

51 篇文章 0 订阅

订阅专栏

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]
提示：

0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums 是一个非递减数组
-109 <= target <= 109

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int n=nums.length;
        if(n==0)return new int[]{-1,-1};
        int left=findLeft(nums,target);//二分找左边第一个目标值
        int right=findRight(nums,target);//二分找右边最后一个目标值
        return new int[]{left,right};
    }

    public int findLeft(int[] nums,int target){
        int l=0,r=nums.length-1;
        while(l<=r){
            int mid=(l+r)/2;
            if(nums[mid]<target){//中值小于target,target范围重定向为[mid+1,right]
                l=mid+1;
            }else if(nums[mid]>target){//中值大于target,target范围重定向为[left,mid-1]
                r=mid-1;
            }else{
                if(mid>0&&nums[mid-1]==nums[mid]){//判断前面是否有target值，有则重定向范围为[left,mid-1]
                    r=mid-1;
                }else {
                	return mid;
                }
            }
        }
        return -1;
    }
    public int findRight(int[] nums,int target){
        int l=0,r=nums.length-1;
        while(l<=r){
            int mid=(l+r)/2;
            if(nums[mid]<target){//中值小于target,target范围重定向为[mid+1,right]
                l=mid+1;
            }else if(nums[mid]>target){//中值大于target,target范围重定向为[left,mid-1]
                r=mid-1;
            }else{
                if(mid<nums.length-1&&nums[mid+1]==nums[mid]){//判断后面是否有target值，有则重定向范围为[mid+1,right]
                    l=mid+1;
                }else {
                	return mid;
                }
            }
        }
        return -1;
    }
}

/**
    可以看到前面那个找左右边界有重复的部分，加入一个左右边界的判断可以优化代码
**/
class Solution {
    public int[] searchRange(int[] nums, int target) {
        int n=nums.length;
        if(n==0)return new int[]{-1,-1};
        int left=BinarySearch(nums,target,true);//二分找左边第一个目标值
        int right=BinarySearch(nums,target,false);//二分找右边最后一个目标值
        return new int[]{left,right};
    }

    public int BinarySearch(int[] nums,int target,boolean isLeft){
        int l=0,r=nums.length-1;
        while(l<=r){
            int mid=(l+r)/2;
            if(nums[mid]<target){//中值小于target,target范围重定向为[mid+1,right]
                l=mid+1;
            }else if(nums[mid]>target){//中值大于target,target范围重定向为[left,mid-1]
                r=mid-1;
            }else{
                if(mid>0&&nums[mid-1]==nums[mid]&&isLeft){//判断前面、后面是否有target值，有则重定向范围
                    r=mid-1;
                }else if(mid<nums.length-1&&nums[mid+1]==nums[mid]&&!isLeft){
                	l=mid+1;
                }else{
                    return mid;
                }
            }
        }
        return -1;
    }
}