這題一看：升序、時間複雜度的要求：O(log n)，就有思路了：典型的二分查詢嘛！

先用二分查詢找到target所在下標，考慮到target重複的情況，定義左右兩個指標，他們同時從找到的下標位置出發，一個向左，一個向右，直到找到不等於target的下標位置即可

 1 public static int[] searchRange(int[] nums, int target) {
 2         //排除特殊資料：陣列為空，長度為0、1
 3         if (nums == null || nums.length == 0) {
 4             return new
 
 int[]{-1, -1};
 5         }
 6         if (nums.length == 1) {
 7             if (nums[0] == target) {
 8                 return new int[]{0, 0};
 9             } else {
10                 return new int[]{-1, -1};
11             }
12         }
13         //排除完畢，開始二分查詢，index是查詢結果，flag標記是否查詢成功，預設false
14         int
 
 low = 0, high = nums.length - 1;
15         int index = 0;
16         boolean flag = false;
17         while (low <= high) {
18             int mid = (low + high) / 2;
19             if (target == nums[mid]) {
20                 index = mid;
21                 flag = true;
22                 break;
 
23             } else if (target > nums[mid]) {
24                 low = mid + 1;
25             } else {
26                 high = mid - 1;
27             }
28         }
29         //沒有找到target
30         if (flag == false) {
31             return new int[]{-1, -1};
32         }
33         //以target的下標index為中心，向左，向右分別遍歷，找到邊界
34         int left = index - 1, right = index + 1;
35         while (left >= 0 && nums[left] == target) {
36             left--;
37         }
38         while (right < nums.length && nums[right] == target) {
39             right++;
40         }
41         return new int[]{left + 1, right - 1};
42     }