二分查找代码实现

不含重复元素

package binarySearch;

import org.junit.Test;

import java.util.Arrays;

/**
 * 不含重复元素的二分查找
 */
public class SimpleBinarySearch {
    //循环实现
    public int binarySearch(int[] array, int value) {
        int low = 0;
        int high = array.length - 1;

        while (low <= high) {
            int mid = (low + high) / 2;
            if (array[mid] == value) {
                return mid;
            } else if (array[mid] < value) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return -1;
    }

    //递归实现
    public int recursionBinarySearch(int[] array, int value, int low, int high) {
        if (low > high) {
            return -1;
        }
        int mid = (low + high) / 2;
        if (array[mid] == value) {
            return mid;
        } else if (array[mid] < value) {
            return recursionBinarySearch(array, value, mid + 1, high);
        } else {
            return recursionBinarySearch(array, value, low, mid - 1);
        }
    }

    @Test
    public void testBinarySearch() {
        int[] array = new int[10];
        array[0] = 6;
        array[1] = 12;
        array[2] = 15;
        array[3] = 19;
        array[4] = 24;
        array[5] = 26;
        array[6] = 29;
        array[7] = 35;
        array[8] = 46;
        array[9] = 67;
        System.out.println(Arrays.toString(array));
//        int i = binarySearch(array, 1);
        int i = recursionBinarySearch(array, 15, 0, array.length - 1);
        if (i != -1) {
            System.out.println("找到了目标元素的下标:" + i + "---对应的值为:" + array[i]);
        } else {
            System.out.println("查找的元素不存在");
        }
    }
}

包含重复元素的实现四种查找要求

package binarySearch;

import org.junit.Test;

/**
 * 数据序列含重复元素的二分查找
 */
public class BinarySearch {
    /**
     * 查找数据序列中第一个等于给定值的元素的下标
     * @param array
     * @param value
     * @return
     */
    public int binarySearch(int[] array,int value){
        int low = 0;
        int high = array.length - 1;
        while(low <= high){
            int mid = (low + high) / 2;
            if(array[mid] == value){
                //当mid指针已经指向第一个元素，或者mid指针的前一个元素不等与我们查找元素的时候直接返回mid下标
                if(mid == 0 || array[mid-1] != value){
                    return mid;
                }else{
                    high = mid - 1;
                }
            }else if(array[mid] < value){
                low = mid + 1;
            }else {
                high = mid - 1;
            }
        }
        return -1;
    }

    @Test
    public void test1() {
        int[] array = new int[10];
        array[0] = 6;
        array[1] = 12;
        array[2] = 15;
        array[3] = 19;
        array[4] = 24;
        array[5] = 26;
        array[6] = 29;
        array[7] = 29;
        array[8] = 29;
        array[9] = 67;

        int i = binarySearch3(array, 29);
        if (i != -1) {
            System.out.println("找到了目标元素的下标:" + i + "---对应的值为:" + array[i]);
        } else {
            System.out.println("查找的元素不存在");
        }
    }

    /**
     * 从数据序列查找最后一个值等于给定值的元素
     * @param array
     * @param value
     * @return
     */
    public int binarySearch2(int[] array,int value){
        int low = 0;
        int high = array.length - 1;
        while(low <= high){
            int mid = (low + high) / 2;
            if(array[mid] == value){
                //当mid指针已经指向最后一个元素，或者mid指针的后一个元素不等与我们查找元素的时候直接返回mid下标
                if(mid == array.length - 1 || array[mid+1] != value){
                    return mid;
                }else{
                    low = mid + 1;
                }
            }else if(array[mid] < value){
                low = mid + 1;
            }else {
                high = mid - 1;
            }
        }
        return -1;
    }

    @Test
    public void test2() {
        int[] array = new int[10];
        array[0] = 6;
        array[1] = 12;
        array[2] = 15;
        array[3] = 19;
        array[4] = 24;
        array[5] = 26;
        array[6] = 29;
        array[7] = 29;
        array[8] = 29;
        array[9] = 67;

        int i = binarySearch2(array, 29);
        if (i != -1) {
            System.out.println("找到了目标元素的下标:" + i + "---对应的值为:" + array[i]);
        } else {
            System.out.println("查找的元素不存在");
        }
    }

    /**
     * 从数据序列中查找第一个大于等于给定值的元素
     * @param array
     * @param value
     * @return
     */
    public int binarySearch3(int[] array,int value){
        int low = 0;
        int high = array.length - 1;
        while(low <= high){
            int mid = (low + high) / 2;

            if(array[mid] >= value){
                if(mid == 0 || array[mid-1] < value){
                    return mid;
                }else {
                    high = mid - 1;
                }
            }else{
                low = mid + 1;
            }
        }
        return -1;
    }

    @Test
    public void test3() {
        int[] array = new int[10];
        array[0] = 6;
        array[1] = 12;
        array[2] = 15;
        array[3] = 19;
        array[4] = 24;
        array[5] = 26;
        array[6] = 29;
        array[7] = 29;
        array[8] = 29;
        array[9] = 67;

        int i = binarySearch3(array, 23);
        if (i != -1) {
            System.out.println("找到了目标元素的下标:" + i + "---对应的值为:" + array[i]);
        } else {
            System.out.println("查找的元素不存在");
        }
    }

    /**
     * 查找出最后一个值小于等于给定值的元素
     * @param array
     * @param value
     * @return
     */
    public int binarySearch4(int[] array,int value){
        int low = 0;
        int high = array.length - 1;
        while(low <= high){
            int mid = (low + high) / 2;

            if(array[mid] <= value){
                if(mid == array.length - 1 || array[mid+1] > value){
                    return mid;
                }else {
                    low = mid + 1;
                }
            }else{
                high = mid - 1;
            }
        }
        return -1;
    }

    @Test
    public void test4() {
        int[] array = new int[10];
        array[0] = 6;
        array[1] = 12;
        array[2] = 15;
        array[3] = 19;
        array[4] = 24;
        array[5] = 26;
        array[6] = 29;
        array[7] = 29;
        array[8] = 29;
        array[9] = 67;

        int i = binarySearch4(array, 23);
        if (i != -1) {
            System.out.println("找到了目标元素的下标:" + i + "---对应的值为:" + array[i]);
        } else {
            System.out.println("查找的元素不存在");
        }
    }
}