Binary Search

Time complexity O(log(n)). When the question requires O(log(n)) time complexity, we always need to think whether it can be solved by binary search.

For binary search, there are several key elements to consider:

1. when to stop while loop?

2. how to change start pointer?

3. how to change end pointer?

4. is it required to find first/ last/ any position of target?

5. use iterative or recursive way, which is better?

According to template provide by Jiuzhang, we concludes a general way to implement binary sort.

class Solution {
    /**
     * @param nums: The integer array.
     * @param target: Target to find.
     * @return: The first position of target. Position starts from 0.
     */
    public int binarySearch(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        int start = 0, end = nums.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] == target) {
                end = mid;  
            } else if (nums[mid] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (nums[start] == target) {
            return start;
        }
        if (nums[end] == target) {
            return end;
        }
        return -1;
    }
}

From the template, we noticed that:

1. Each time, we set start = mid or end = mid to avoid index out of range.

2. Stop criterion is a. target is found b. start + 1 = end (i.e start and end are adjacent points).

In second situation, we need to check both start and end pointers.

If it's required to return first position --> first check start, then check end.

If it's required to return last position --> first check end, then check start.