BST: when to use i <= j or i < j

i <= j

• BST for target

　　public int search(int[] nums, int target) {

　　　　int i=0, j=nums.length-1;
　　　　while (i <= j) {
　　　　　　int mid = i+(j-i)/2;
　　　　　　if (nums[mid] == target) {
　　　　　　　　return mid;
　　　　　   } else if (nums[mid] < target) {

　　　　　　　　i = mid + 1;
　　　　　　} else {
　　　　　　　　j = mid - 1;
　　　　　　}
　　　　}
　　　　return -1;
　　}

 

• BST for insertion index of target. If target is not found, return its insertion place to make the array still sorted.

　　

/* Find the first larger or equal. */
/* Invariant: intdex is in range [low, high+1]. */

　　　　public int insertIndex(int[] nums, int target) {
　　　　　　int lo = 0, hi = nums.length-1;
　　　　　　while (lo <= hi) {
　　　　　　　　int mid = lo+(hi-lo)/2;
　　　　　　　　if (nums[mid] < target) {
　　　　　　　　　　lo = mid + 1;
　　　　　　　　} else {
　　　　　　　　　　hi = mid - 1;
　　　　　　　　}
　　　　　　}
　　　　　　return lo;
　　　　}

 

The following code to find the first larger or equal element is based on an assumption that the last element of the list is greater than or equal to the target.

private int findFirstLargeEqual(List<Integer> seq, int target)
{
    int lo = 0;
    int hi = seq.size() - 1;
    while(lo < hi)
    {
        int mid = lo + (hi - lo) / 2;
        if(seq.get(mid) < target) lo = mid + 1;
        else hi = mid;
    }

    return lo;
}

 

i < j 

public int mySqrt(int x) {
        if (x<=1) return x;
        int left = 1, right = x;
        while (left < right) { // In this case, when left = right, left*left always bigger than x. 
            int mid = left+(right-left)/2;
            if (mid <= x/mid) { // to avoid integer overflow.
                left = mid+1;
            } else  {
                right = mid;
            } 
        }
        return left-1;
       
}

In this case, i <= j may lead to infinite loop.