个人记录-LeetCode 34. Search for a Range

问题：
Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm’s runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,
Given [5, 7, 7, 8, 8, 10] and target value 8,
return [3, 4].

代码示例：

1、这个题目没什么难度，从复杂度来看，二分法即可。

public class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums == null || nums.length < 1) {
            return new int[] {-1, -1};
        }

        if (nums.length < 2) {
            if (nums[0] == target) {
                return new int[] {0, 0};
            } else {
                return new int[] {-1, -1};
            }
        }

        Set<Integer> result = new TreeSet<>();
        searchResult(nums, 0, nums.length-1, target, result);

        if (result.isEmpty()) {
            return new int[] {-1, -1};
        } else {
            Object[] temp = result.toArray();
            return new int[] {(int)temp[0], (int)temp[temp.length-1]};
        }
    }

    private void searchResult(int[] nums, int begin, int end, int target, Set<Integer> result) {
        if (begin > end) {
            return;
        }

        int middle = (begin + end) / 2;
        if (nums[middle] == target) {
            result.add(middle);
        }

        if (nums[middle] >= target) {
            if (nums[begin] <= target) {
                searchResult(nums, begin, middle - 1, target, result);
            }
        }

        if (nums[middle] <= target) {
            if (nums[end] >= target) {
                searchResult(nums, middle + 1, end, target, result);
            }
        }
    }
}

2、二分法反复递归，比较耗时，改进的方法：

public class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums == null || nums.length < 1) {
            return new int[] {-1, -1};
        }

        if (nums.length < 2) {
            if (nums[0] == target) {
                return new int[] {0, 0};
            } else {
                return new int[] {-1, -1};
            }
        }

        int low = 0;
        int high = nums.length - 1;
        boolean flag = false;

        while (low <= high) {
            int middle = (low + high) / 2;

            if (nums[middle] == target) {
                flag = true;

                low = middle;
                while (low > 0 && nums[low-1] == target) {
                    --low;
                }

                high = middle;
                while (high < nums.length-1 && nums[high+1] == target) {
                    ++high;
                }

                break;
            } else if (nums[middle] > target){
                high = middle - 1;
            } else {
                low = middle + 1;
            }
        }

        if (flag) {
            return new int[] {low, high};
        } else {
            return new int[] {-1, -1};
        }
    }
}

3、一直二分法查找

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums == null) {
            return new int[]{-1, -1};
        }


        int leftIndex = binarySearch(nums, target, 0, true);
        if (leftIndex < 0) {
            return new int[]{-1, -1};
        }

        int rightIndex = binarySearch(nums, target, leftIndex, false);

        return new int[] {leftIndex, rightIndex};
    }

    private int binarySearch(int[] nums, int target, int start, boolean searchLeft) {
        int ret = -1;

        int left = start;
        int right = nums.length - 1;

        while (left <= right) {
            int mid = (left + right) / 2;

            if (target == nums[mid]) {
                ret = mid;

                if (searchLeft) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                if (target > nums[mid]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }

        return ret;
    }
}