给定一个按照升序排列的整数数组 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
使用二分法查找第一个位置,初始化两个变量low=0,hight=nums.length-1
1、当low>high时,表示没有找到,返回-1
2、mid=(low+high)/2
3、假如low等于high,返回下标mid
4、假如nums[mid]等于target且nums[mid]比相邻的左侧元素大,返回下标mid
5、当目标值小于等于nums[mid]时,说明目标值在左侧,往左侧递归查找,否则往右侧递归查找
查找最后一个位置同理,唯一不同的是第4、5步
4、假如nums[mid]等于target且nums[mid]比相邻的右侧元素小,返回下标mid
5、当目标值大于等于nums[mid]时,说明目标值在右侧,往右侧递归查找,否则往左侧递归查找
package search_range;
public class Solution {
public int[] searchRange(int[] nums, int target) {
int first=searchIndexFirst(nums,0,nums.length-1,target);
int last=searchIndexLast(nums,0,nums.length-1,target);
int[] rs={first,last};
return rs;
}
public int searchIndexFirst(int[] nums, int low,int high,int target) {
if(low>high){
return -1;
}
int mid=(low+high)/2;
if(nums[mid]==target&&low==high){
return mid;
}
if(nums[mid]==target&&(mid==0||nums[mid-1]<nums[mid])){
return mid;
}
if(target<=nums[mid]){
//寻找第一个位置,当目标值小于等于中间值,往左寻找
return searchIndexFirst(nums,low,mid-1,target);
}else{
return searchIndexFirst(nums,mid+1,high,target);
}
}
public int searchIndexLast(int[] nums, int low,int high,int target) {
if(low>high){
return -1;
}
int mid=(low+high)/2;
if(nums[mid]==target&&low==high){
return mid;
}
if(nums[mid]==target&&nums[mid]<nums[mid+1]){
return mid;
}
if(target>=nums[mid]){
//寻找最后一个位置,当目标值大于等于中间值,往右寻找
return searchIndexLast(nums,mid+1,high,target);
}else{
return searchIndexLast(nums,low,mid-1,target);
}
}
public static void main(String[] args) {
int[] nums = {1};
Solution solution=new Solution();
int[] rs = solution.searchRange(nums, 8);
for(int i=0;i<rs.length;i++){
System.out.println(rs[i]);
}
}
}
时间复杂度: O(logn) ,其中 n 为数组的长度。二分查找的时间复杂度为 O(logn),一共会执行两次,因此总时间复杂度为O(logn)。
空间复杂度:O(1) 。只需要常数空间存放若干变量。