二分查找的最全版本

package SearchTest;

public class binarySearch {

    //不分先后的查找
    public static int binarySearch0(int [] a,int left,int right,int val){
        if(left>right||a==null) return -1;
        while(left<=right){
            int mid=(left+right)/2;
            if(a[mid]==val) return mid;
            else if(a[mid]>val) right=mid-1;
            else left=mid+1;
        }
        return -1;
    }


    //查找的出现的最后一个位置
    //思路是找到右边界，判断的时候边界右侧的全部大于目标值，边界左侧的小于等于
    public static int binarySearch1(int [] a,int left,int right ,int val){
        if(left>right||a==null) return -1;
        while(left<right-1){
            int mid=(left+right)/2;
            if(a[mid]>val) right=mid-1;
            else left=mid;
        }
        if(a[right]==val) return right;
        else if(a[left]==val) {
            return left;
        }
        return -1;
    } 


    //查找的是出现的第一个位置
    //思路是找到左边界，判断的时候边界左侧的全部小于目标值，边界右侧的大于等于目标值
    public static int binarySearch2(int [] a,int left,int right ,int val){
        if(left>right||a==null) return -1;
        while(left<right-1){
            int mid=(left+right)/2;
            if(a[mid]<val) left=mid+1;
            else right=mid;
        }
        if(a[left]==val) return left;
        else if(a[right]==val) {
            return right;
        }
        return -1;
    } 


    //查找第一个大于等于目标值
    //思路是找到左边界，判断的时候边界左侧的全部小于目标值，边界右侧的大于等于目标值
    public static int binarySearch3(int [] a,int left,int right ,int val){
        if(left>right||a==null) return -1;
        while(left<right-1){
            int mid=(left+right)/2;
            if(a[mid]<val) left=mid+1;
            else right=mid;
        }
        if(a[left]>=val) return left;
        else if(a[right]>=val) {
            return right;
        }
        return -1;
    }

    //查找第一个大于目标值
    //思路是找到左边界，判断的时候边界左侧的全部小于等于目标值，边界右侧的大于目标值
    public static int binarySearch4(int [] a,int left,int right ,int val){
        if(left>right||a==null) return -1;
        while(left<right-1){
            int mid=(left+right)/2;
            if(a[mid]<=val) left=mid+1;
            else right=mid;
        }
        if(a[left]>val) return left;
        else if(a[right]>val) {
            return right;
        }
        return -1;
    }

    //查找最后一个小于目标值的元素位置
    //思路是找到右边界，判断的时候边界右侧的全部大于等于目标值，边界左侧的小于目标值
    public static int binarySearch5(int [] a,int left,int right ,int val){
        if(left>right||a==null) return -1;
        while(left<right-1){
            int mid=(left+right)/2;
            if(a[mid]>=val) right=mid-1;
            else left=mid;
        }
        if(a[right]<val) return right;
        else if(a[left]<val) {
            return left;
        }
        return -1;
    }

    //查找最后一个小于等于目标值的元素位置
    //思路是找到右边界，判断的时候边界右侧的全部大于目标值，边界左侧的小于等于目标值
        public static int binarySearch6(int [] a,int left,int right ,int val){
            if(left>right||a==null) return -1;
            while(left<right-1){
                int mid=(left+right)/2;
                if(a[mid]>val) right=mid-1;
                else left=mid;
            }
            if(a[right]<=val) return right;
            else if(a[left]<=val) {
                return left;
            }
            return -1;
        }

    public static void main(String[] args) {
        int[] a = { 1,2,2,3,3,3,5,5,6,6,7,7};
        System.out.println("目标值2在数组中的位置为："+binarySearch0(a,0,a.length-1,2));
        System.out.println("目标值2在数组中最后一次出现的位置为："+binarySearch1(a,0,a.length-1,2));
        System.out.println("目标值2在数组中第一次出现的位置为："+binarySearch2(a,0,a.length-1,2));
        System.out.println("第一个大于等于目标值2的的位置为："+binarySearch3(a,0,a.length-1,2));
        System.out.println("第一个大于目标值2的的位置为："+binarySearch4(a,0,a.length-1,2));
        System.out.println("第一个小于目标值2的的位置为："+binarySearch5(a,0,a.length-1,2));
        System.out.println("第一个小于等于目标值2的的位置为："+binarySearch6(a,0,a.length-1,2));
    }
}


结果：
目标值2在数组中的位置为：2
目标值2在数组中最后一次出现的位置为：2
目标值2在数组中第一次出现的位置为：1
第一个大于等于目标值2的的位置为：1
第一个大于目标值2的的位置为：3
第一个小于目标值2的的位置为：0
第一个小于等于目标值2的的位置为：2