LeetCode--在排序数组中查找元素的第一个和最后一个位置

LeetCode链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/

题目：

　　给定一个按照升序排列的整数数组nums，和一个目标值target，找出给定目标值在数组中的开始位置和结束位置，当数组中不存在目标值时返回[-1, -1]；

要求：

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

　　我有两种解决该问题的方案：

　　　　方案一：先通过二分查找，找到目标值target在数组中的位置mid，然后以mid为中心，向两边依次查找是否有与target相同的数组元素

public class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums == null || nums.length == 0) return new int[] {-1, -1};
        if(nums.length == 1) return nums[0] == target ? new int[] {0, 0} : new int[] {-1, -1};
        int left = 0, right = nums.length - 1, mid = 0;
        while(left <= right) {      // 二分查找target在数组中的位置，如果数组中有多个与target相等的元素，则返回其中的某一个元素的下标
            mid = (left + right) / 2;
            if(nums[mid] == target) {
                break;
            }
            else if(nums[mid] < target) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        if(left > right) return new int[] {-1, -1};   // 如果数组中不存在该目标值，则返回[-1, -1]
        left = mid - 1;
        right = mid + 1;
        while(left > -1 && nums[left] == nums[mid]) {  // 以mid为中心，向左边查找与target值相同的数组元素
            left--;
        }
        while(right < nums.length && nums[right] == nums[mid]) {    // 以mid为中心，向右边查找与target相同的元素
            right++;
        }
        return new int[] {left+1, right-1};   // 返回target元素在数组中的开始位置和结束位置
    }
}

　　时间复杂度：二分查找mid的过程时间复杂度为O(log n)，以mid为中心向两边查找的过程，每一次查找的时间复杂度为O(1)，但在最坏情况下， 即数组的每个元素的值都为target的情况下(如nums=[8, 8, 8, 8, 8, 8], target=8)，整个查找过程的时间复杂度为O(n)，所以在最坏情况下不满足题目要求的时间复杂度为O(log n)级别。

　　

　　方案一中，二分查找mid的过程时间复杂度为O(log n)，只是查找左右边界的过程时间复杂度达到O(n)，所以关键在于找到mid过后，应该如何查找左右边界的问题。

　　方案二：二分查找mid的过程不变，但在查找左右边界的过程中将不再采用逐个比较查找，而是二分查找算法，这样就可以在O(log n)的时间内找到左右边界

public class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums == null || nums.length == 0) return new int[] {-1, -1};
        if(nums.length == 1) return nums[0] == target ? new int[] {0, 0} : new int[] {-1, -1};
        int pos = findTargetIndex(nums, 0, nums.length-1, target);
        int left = findLeftBoundaryIndex(nums, 0, pos - 1, target);
        int right = findRightBoundaryIndex(nums, pos + 1, nums.length-1, target);
        left = left == -1 ? pos : left;
        right = right == -1 ? pos : right;
        return new int[] {left, right};
        
    }
    
    public int findLeftBoundaryIndex(int[] nums, int left, int right, int target) {  // 二分法查找左边界
        int mid = 0;
        int boundary = -1;
        while(left <= right) {
            mid = (left + right) / 2;
            if(nums[mid] != target) {
                left = mid + 1;
            }
            else {
                right= mid - 1;
                boundary = mid;
            }
        }
        return boundary;
    }
    
    public int findRightBoundaryIndex(int[] nums, int left, int right, int target) {  // 二分法查找右边界
        int mid = 0;
        int boundary = -1;
        while(left <= right) {
            mid = (left + right) / 2;
            if(nums[mid] != target) {
                right = mid - 1;
            }
            else {
                left= mid + 1;
                boundary = mid;
            }
        }
        return boundary;
    }
    
    public int findTargetIndex(int[] nums, int left, int right, int target) {
        int mid = 0;
        while(left <= right) {
            mid = (left + right) / 2;
            if(nums[mid] == target) {
                return mid;
            }
            else if(nums[mid] < target) {
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }
        return -1;
    }
}

 　　这个方案虽然满足时间复杂度为O(log n)级别，但是在算法中仍然有几处冗余，第一个是在二分查找pos的过程和二分查找左右边界的过程，这两大过程中有些地方做了重复判断的；第二个是二分查找左右边界这两个过程的代码，存在大部分冗余，只有几行关键代码是不同的，有没有什么方法可以让这两个函数合并成一个查找左右边界的接口呢？

　　看了别的题解，可以解决我上面的两个问题，看这里

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] range = new int[] {-1, -1};
        
        if(nums == null || nums.length == 0) return range;
        if(nums.length == 1) return nums[0] == target ? new int[] {0, 0} : range;
        
        int leftIndex = searchRange(nums, target, true);
        if(leftIndex == nums.length || nums[leftIndex] != target) {  // 如果数组中不存在target
            return range;
        }
        range[0] = leftIndex;
        range[1] = searchRange(nums, target, false) - 1;  // 寻找右边界时之所以不用判断，是因为前面在找左边界的过程中已经确保了能走到这一步说明数组中必然存在target
        return range;
    }
    
    public int searchRange(int[] nums, int target, boolean flag) {
        int left = 0;
        int right = nums.length;
        int mid = 0;
        while(left < right) {
            mid = (left + right) / 2;
            if(nums[mid] > target || (flag && nums[mid] == target)) {
                right = mid;
            }
            else {
                left = mid + 1;
            }
        }
        return left;
    }
}

　　还有一种线性扫描思路，从左右两边往中间寻找的方法，时间复杂度为O(n)，看这里

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] range = new int[] {-1, -1};
        if(nums == null || nums.length == 0) return range;
        if(nums.length == 1) return nums[0] == target ? new int[] {0, 0} : range;
        
        int left = 0; 
        int right = nums.length - 1;
        while(left < nums.length && nums[left] != target) {   // 顺序遍历查找左边界
            left++;
        }
        if(left == nums.length) {  // 如果数组中不存在target
            return range;
        }
        range[0] = left;
        while(nums[right] != target) {  // 顺序遍历查找右边界
            right--;
        }
        range[1] = right;
        return range;        
    }
}