二分查找及其变种

1. 二分查找

关于二分查找算法：二分查找法主要是解决在“一堆数中找出指定的数”这类问题。而想要应用二分查找法，这“一堆数”必须有以下特征：
(1) 存储在数组中
(2) 有序排列
请实现正确的二分查找算法（迭代与递归）。ps: 本题指最简单的二分查找算法：针对有序无重复元素数组。

• 迭代法

/**********二分查找（迭代）**********/
public static int binarySearchIteration(int[] array, int target){
    if(array == null || array.length == 0){
        return -1;
    }
    int low = 0;
    int high = array.length - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if(array[mid] > target){
            high = mid - 1;
        }else if(array[mid] < target){
            low = mid + 1;
        }else{
            return mid;
        }
    }
    return -1;
}

• 递归法

/**********二分查找（递归）**********/
public static int binarySearchRecursion(int[] array, int target){
    if(array == null || array.length == 0){
        return -1;
    }
    return bsr(array, target, 0, array.length - 1);
    }
    public static int bsr(int[] array, int target, int low, int high){
    if(low <= high){
        int mid = low + ((high - low) >> 1);
        if(array[mid] > target){
            return bsr(array, target, low, mid - 1);
        }else if(array[mid] < target){
            return bsr(array, target, mid + 1, high);
        }else{
            return mid;
        }
    }
    return -1;
}

2. 二分查找的变种

• 查找第一个等于给定值的元素

/**********二分查找（迭代）**********/
//函数1功能：查找第一个值等于给定值的元素
public static int bsFirst(int[] array, int target){
    if(array == null || array.length == 0){
        return -1;
    }
    int low = 0;
    int high = array.length - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if(array[mid] > target){
            high = mid - 1;
        }else if(array[mid] < target){
            low = mid + 1;
        }else{
            if(mid == low || array[mid - 1] != array[mid]){
                return mid;
            }else{
                high = mid - 1;
            }
        }
    }
    return -1;
}

• 查找最后一个等于给定值的元素

/**********二分查找（迭代）**********/
//函数2功能：查找最后一个值等于给定值的元素
public static int bsLast(int[] array, int target){
    if(array == null || array.length == 0){
        return -1;
    }
    int low = 0;
    int high = array.length - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if(array[mid] > target){
            high = mid - 1;
        }else if(array[mid] < target){
            low = mid + 1;
        }else{
            if(mid == high || array[mid + 1] != array[mid]){
                return mid;
            }else{
                low = mid + 1;
            }
        }
    }
    return -1;
}

• 查找第一个大于等于给定值的元素

/**********二分查找（迭代）**********/
//函数3功能：查找第一个大于等于给定值的元素
public static int bsFirstGE(int[] array, int target){
    if(array == null || array.length == 0){
        return -1;
    }
    int low = 0;
    int high = array.length - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if(array[mid] >= target){
            if(mid == low || array[mid - 1] < target){
                return mid;
            }else{
                high = mid - 1;
            }
        }else{
            low = mid + 1;
        }
    }
    return -1;
}

• 查找最后一个小于等于给定值的元素

/**********二分查找（迭代）**********/
//函数4功能：查找最后一个小于等于给定值的元素
public static int bsLastLE(int[] array, int target){
    if(array == null || array.length == 0){
        return -1;
    }
    int low = 0;
    int high = array.length - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if(array[mid] <= target){
            if(mid == high || array[mid + 1] > target){
                return mid;
            }else{
                low = mid + 1;
            }
        }else{
            high = mid - 1;
        }
    }
    return -1;
}