LeetCode-34-Search for a Range-优快云博客

本文介绍如何使用二分查找法在有序数组中查找指定目标值的起始和结束位置，实现时间复杂度为O(log n)。通过递归和非递归两种方式展示算法实现，并提供详细解析。

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

Search for a Range

来自 <https://leetcode.com/problems/search-for-a-range/>

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,

Given [5, 7, 7, 8, 8, 10] and target value 8,

return [3, 4].

题目解读：

给定一个有序数组nums和一个整数target,找出target在数组中的起始位置。

算法的时间复杂度为O(logn).

如果target在数组中没有找到，则返回[-1, -1]。

例如

给定数组[5, 7, 7, 8, 8, 10] 和target值8.返回[3, 4]。

解析：根据题意可知，由于算法的时间复杂度为O(logn)，并且数组是有序数组，所以要使用二分查找。在二分查找结束后，根据找到的一个索引，再向两边扩充。

Java代码一（递归）：

public class Solution {
	/**
	 * 二分查找递归
	 * @param nums
	 * @param target
	 * @return
	 */
	public int[] searchRange1(int[] nums, int target) {
		int[] result = new int[2];
		int low = 0;
		int high = 0;
		int location = binarysearch(nums, target, 0, nums.length-1);
		
		/**
		 * 如果没有找到
		 */
		if(-1 == location) {
			result[0]=-1;
			result[1]=-1;
		} else {
			/**
			 * 如果找到其中的一个值
			 */
			//向左扩充
			for(low=location; low>=0; low--) {
				if(nums[low] != nums[location])
					break;
			}
			//向右扩充
			for(high=location; high<nums.length; high++) {
				if(nums[high] != nums[location]) {
					break;
				}
			}
			
			result[0] = low+1;
			result[1] = high-1;
		}
		return result;
	}
	
	/**
	 * 递归二分查找算法
	 * @param nums
	 * @param target
	 * @param low
	 * @param high
	 * @return
	 */
	public int binarysearch(int[] nums, int target, int low,int high) {
		if(low>high)
			return -1;
		int mid = (low+high) /2;
		if(target == nums[mid])
			return mid;
		else if(target > nums[mid])
			return binarysearch(nums, target, mid+1, high);
		else
			return binarysearch(nums, target, low, mid-1);
	}
	
}

递归性能：

Java代码二（非递归）：

public class Solution {
	/**
	 * 二分查找非递归
	 * @param nums
	 * @param target
	 * @return
	 */
	public int[] searchRange(int[] nums, int target) {
		int[] result = new int[2];
		int low = 0;
		int high = nums.length-1;
		int mid = 0;
		
		/**
		 * 二分查找找出序列中的一个target值
		 */
		while(low<=high) {
			mid = (low+high) / 2;
			if(target == nums[mid])
				break;
			else if(target < nums[mid])
				high = mid-1;
			else
				low = mid+1;
				
		}
		/**
		 * 如果没找到
		 */
		if(low > high) {
			result[0] = -1;
			result[1] = -1;
			return result;
		}
		
		/**
		 * 如果找到其中的一个值
		 */
		//向左扩充
		for(low=mid; low>=0; low--) {
			if(nums[low] != nums[mid])
				break;
		}
		//向右扩充
		for(high=mid; high<nums.length; high++) {
			if(nums[high] != nums[mid]) {
				break;
			}
		}
		
		result[0] = low+1;
		result[1] = high-1;
		return result;
    }
}

非递归性能：