LeetCode刷题笔记 34. 在排序数组中查找元素的第一个和最后一个位置

题目描述

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

总结

SC的return new int[]{start, firstGreaterEqual(A, target + 1) - 1};这句写的太神了⑧
DC就是暴搜, 不过相比DC2用了二分法

Sample Code

public class Solution {
	public int[] searchRange(int[] A, int target) {
		int start = Solution.firstGreaterEqual(A, target);
		if (start == A.length || A[start] != target) {
			return new int[]{-1, -1};
		}
		return new int[]{start, firstGreaterEqual(A, target + 1) - 1};
	}

	//find the first number that is greater than or equal to target.
	//could return A.length if target is greater than A[A.length-1].
	//actually this is the same as lower_bound in C++ STL.
	private static int firstGreaterEqual(int[] A, int target) {
		int low = 0, high = A.length;
		while (low < high) {
			int mid = low + ((high - low) >> 1);
			//low <= mid < high
			if (A[mid] < target) {
				low = mid + 1;
			} else {
				//should not be mid-1 when A[mid]==target.
				//could be mid even if A[mid]>target because mid<high.
				high = mid;
			}
		}
		return low;
	}
}

Demo Code (faster)

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] res = {-1, -1};
        int left = 0, right = nums.length-1;
        int mid = (left+right) / 2;
        while(left <= right) {
            if(nums[mid] == target) {
                
                int temp = mid;
                // System.out.println(temp);
                while(mid > 0 && nums[mid-1] == target) mid--;
                res[0] = mid;
                while(temp < nums.length-1 && nums[temp+1] == target) temp++;
                res[1] = temp;
                break;
            }else if(nums[mid] > target) { 
                right = mid-1;
            }else {
                left = mid+1;            
            }
            if(left < nums.length && nums[left] == target) {
                while(left > 0 && nums[left-1] == target) left--;
                res[0] = left;
                
            }
            if(right > 0 && nums[right] == target) {
                while(right < nums.length-1 && nums[right+1] == target) right++;
                res[1] = right;
            }
            mid = (left+right) / 2;
        }
        return res;
    }
}

Demo Code 2

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] res = {-1, -1}; 
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] > target) break;
            if(nums[i] == target) {
                if(res[0] == -1) res[0] = i;
                res[1] = i;
            }
        }
        return res;
    }
    
}