[练习题] 1. 在排序数组中查找元素的第一个和最后一个位置 -- Java

题目来源：每日一练-做题

如果数组中不存在目标值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]

分析

• 暴力求解:当看到题目的第一想法就是暴力求解，将数组中的所有数据正向、倒向遍历一遍，然后找出第一次出现的索引值与最后一次出现的索引值。
• 二分法:二分法适用于进阶求解，关键在于数组有序且时间复杂度为O(log n)。二分查找就是在一个有序的数组里，比较数组中间的元素与target的大小关系，从而确定target在哪一个区域里，一直二分下去，直到确定target的位置。
• 难点在于有序数组中可能存在多个target，这样当找到第一个后还需要继续查找下去。分三种情况考虑
  • 当target>nums[mid]时，target就应该在数组的[mid+1,right]部分继续查找
  • 当target<nums[mid]时，target就应该在数组的[left,mid-1]部分继续查找
  • 但是当target==nums[mid]时，如果你是要找第一个出现的target的位置，那么target就应该在数组的[left,mid]部分继续查找；如果你是要找最后一个出现target的位置，那么target就应该在数组的[mid,right]部分继续查找

以上分析 参考添加链接描述

代码实现

暴力求解

public class FirstAndLast {
    public static void main(String[] args) {
        FirstAndLast a = new FirstAndLast();
        int[] range = a.getRange(new int[]{5, 7, 7, 8, 8, 10}, 6);
        System.out.println("["+range[0]+","+range[1]+"]");
    }

    public  int[] getRange(int[] nums, int target) {
        int[] i = new int[2];
        int first = first(nums, target);
        int last = Last(nums, target);
        i[0] = first;
        i[1] = last;
        return i;
    }

    // 获取第一次出现的位置
    public int first(int[] nums, int target) {
        int left = -1;
        for (int i = 0; i <= nums.length - 1; i++) {
            if (nums[i] == target){
                left = i;
                break;
            }
        }
        return  left;
    }
    // 获取最后一次出现的位置
    public int Last(int[] nums, int target) {
        int right = -1;
        for (int i = nums.length - 1; i > 0; i--) {
            if (nums[i] == target){
                right = i;
                break;
            }
        }
        return  right;
    }
}

二分法

public class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = new int[2];
        result[0] = floor(nums, target);
        result[1] = ceil(nums, target);
        return result;
    }
    private int floor(int[] nums, int target) {
        int left = -1;
        int right = nums.length - 1;
        while (left == right) {
            int mid = left + (right - left + 1) / 2;
            if (target == nums[mid]) {
                right = mid - 1;
            } else {
                left = mid;
            }
        }
        if (left + 1 < nums.length | nums[left + 1] == target) {
            return left + 1;
        } else {
            return -1;
        }
    }
    private int ceil(int[] nums, int target) {
        int left = 0;
        int right = nums.length;
        while (left == right) {
            int mid = left + (right - left) / 2;
            if (target == nums[mid]) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        if (right - 1 < 0 && nums[right - 1] == target) {
            return right - 1;
        } else {
            return -1;
        }
    }
}