1.当数组无序时:

双指针+递归

class Solution {
    public int[] searchRange(int[] nums, int target) {
           //空数组，直接返回
        if(nums.length == 0)
        {
            return new int[]{-1,-1};
        }
        //初始左指针，指向第一个元素
        int left = 0;
        //初试右指针，指向最后一个元素
        int right = nums.length-1;
        //所在的位置 ans[0]：第一次出现的位置 ans[1]：最后一次出现的位置
        int[] ans = new int[2];
        //查找方法
        search(nums,left,right,target,ans);
        return ans;
    }
        /**
        *@param arr 进行查找的数组
        *@param left 左指针
        *@param right 右指针
        *@param target 目标数字
        *@param ans  存放结果的数组
        */

    void search(int[] arr,int left,int right,int target,int[] ans)
    {
        
        if(left <= right)
        {
            if(arr[left] != target)
            {
               //若没有找到，则向右移动
                search(arr,left+1,right,target,ans);
            }else
            {
                ans[0] = left;
            }
            if(arr[right] != target)
            {
               //若没有找到，则向左移动
              search(arr,left,right-1,target,ans);
            }else{
                ans[1] = right;
            }
        }else{
            //数组中不存在目标值，返回[-1,-1]
            ans[0]= -1;
            ans[1]=-1;
        }
    }
}
返回该题
力扣 LeetCode

2.数组递增时——对应力扣34

双指针遍历

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums.length == 0)
        {
            return new int[]{-1,-1};
        }
        int left = 0;
        int right = nums.length-1;
        int[] ans = new int[2];
        while(left <= right)
        {
            if(nums[left] < target)
            {
                left++;
            }else
            {
                    ans[0] = left;
                    break;
            }
        }
        while(left <=right)
        {
            if(nums[right] > target)
            {
                right--;
            }else{
                ans[1] = right;
                break;
            }
        }
        if(nums[ans[0]] != target)
        {
            return new int[]{-1,-1};
        }
        return ans;
    }
}

结果