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] target8.返回[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;
    }
}

非递归性能:



 

 

### LeetCode 475 Heaters Problem Solution and Explanation In this problem, one needs to find the minimum radius of heaters so that all houses can be warmed. Given positions of `houses` and `heaters`, both represented as integer arrays, the task is to determine the smallest maximum distance from any house to its nearest heater[^1]. To solve this issue efficiently: #### Binary Search Approach A binary search on answer approach works well here because increasing the radius monotonically increases the number of covered houses. Start by sorting the list of heaters' locations which allows using binary search for finding closest heater distances quickly. ```python def findRadius(houses, heaters): import bisect houses.sort() heaters.sort() max_distance = 0 for house in houses: pos = bisect.bisect_left(heaters, house) dist_to_right_heater = abs(heaters[pos] - house) if pos < len(heaters) else float('inf') dist_to_left_heater = abs(heaters[pos-1] - house) if pos > 0 else float('inf') min_dist_for_house = min(dist_to_right_heater, dist_to_left_heater) max_distance = max(max_distance, min_dist_for_house) return max_distance ``` This code snippet sorts the lists of houses and heaters first. For each house, it finds the nearest heater either directly or indirectly (to the left side). It calculates the minimal distance between these two options and updates the global maximal value accordingly[^3]. The constraints specify that numbers of houses and heaters do not exceed 25000 while their positions range up to \(10^9\)[^2], making efficient algorithms like binary search necessary due to large input sizes involved.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值