Leetcode刷题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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

感谢labuladong和王尼玛的详细解法，传送门我作了首诗，保你闭着眼睛也能写对二分查找，多图演示 34. 在排序数组中查找元素的第一个和最后一个位置。

class Solution {
    public int[] searchRange(int[] nums, int target) {
//		return searchRangeI(nums, target);
//		return searchRangeII(nums, target);
		return searchRangeIII(nums, target);
	}

	//方法三：一次遍历
	//时间复杂度O(logN)，空间复杂度O(1)
	private int[] searchRangeIII(int[] nums, int target) {
		if (nums == null || nums.length == 0) {
			return new int[]{-1, -1};
		}
		int firstIndex = find(nums, target, true);
		int lastIndex = find(nums, target, false);
		return new int[] {firstIndex, lastIndex};
	}

	private int find(int[] nums, int target, boolean isFindFirst) {
		int left = 0, right = nums.length - 1;
		while (left <= right) {
			int mid = left + (right - left) / 2;
			if (nums[mid] < target) {
				left = mid + 1;
			} else if (nums[mid] > target) {
				right = mid - 1;
			} else {
				//找到target后，开始寻找第一个和最后一个元素
				//查找第一个和最后一个逻辑很类似，这里用一个变量标记
				if (isFindFirst) {
					//不断向左收缩
					if (mid > 0 && nums[mid] == nums[mid - 1]) {
						right = mid - 1;
					} else {
						return mid;
					}
				} else {
					//不断向右收缩
					if (mid < nums.length - 1 && nums[mid] == nums[mid + 1]) {
						left = mid + 1;
					} else {
						return mid;
					}
				}
			}
		}
		return -1;
	}

	//方法二：二分查找寻找左侧和右侧边界
	//时间复杂度O(logN)，空间复杂度O(1)
	private int[] searchRangeII(int[] nums, int target) {
		if (nums == null || nums.length == 0) {
			return new int[]{-1,-1};
		}
		//寻找左侧边界
		int left = findLeft(nums, target);
		//寻找右侧边界
		int right = findRight(nums, target);
		return new int[]{left, right};
	}

	private int findRight(int[] nums, int target) {
		int left = 0;
		int right = nums.length;
		while (left < right) {
			int mid = left + (right - left) / 2;
			//增加左侧边界，即不断向右收缩
			if (nums[mid] == target) {
				left = mid + 1;
			} else if (nums[mid] < target) {
				left = mid + 1;
			} else if (nums[mid] > target) {
				right = mid;
			}
		}
		//循环终止条件是left==right，因为当nums[mid] == target时，left=mid+1，mid=left-1
		if (left == 0 || nums[left - 1] != target) {
			return -1;
		}
		return left - 1;
	}

	private int findLeft(int[] nums, int target) {
		int left = 0;
		int right = nums.length;
		while (left < right) {
			int mid = left + (right - left) / 2;
			//找到元素时，缩小右侧边界，即不断向左收缩
			if (nums[mid] == target) {
				right = mid;
			} else if (nums[mid] < target) {
				left = mid + 1;
			} else if (nums[mid] > target) {
				right = mid;
			}
		}
		//循环结束时，left==right
		//这里的left是指数组中小于target的元素个数，如果target比所有数都大则返回-1
		if (left == nums.length || nums[left] != target) {
			return -1;
		}
		return left;
	}

	//方法一：暴力解法，直接遍历
	//先从左往右遍历，遇到target保存元素的下标值，如果遇不到直接返回-1。再从右往左遍历，遇到target保存元素的下标值
	//时间复杂度O(N)，空间复杂度O(1)
	private int[] searchRangeI(int[] nums, int target) {
		int[] result = new int[]{-1, -1};
		if (nums == null || nums.length == 0) {
			return result;
		}
		for (int i = 0; i < nums.length; i++) {
			if (nums[i] == target) {
				result[0] = i;
				break;
			}
		}
		//如果从左往后搜索不到，说明不存在，直接返回-1
		if (result[0] == -1) {
			return result;
		}

		for (int i = nums.length - 1; i >= 0; i--) {
			if (nums[i] == target) {
				result[1] = i;
				break;
			}
		}
		return result;
	}
}