二分查找算法学习记录之两种实现方式

　　二分查找算法，也称折半查找，是一种效率较高的查找算法。使用要求：线性表必须是顺序储存结构，且表中元素按关键字有序排列。

public class Test {
    /**
     * 冒泡排序
     *
     * @param arr 整数数组
     */
    public static void bubble(int[] arr) {
        int swap;
        int len = arr.length;
        for (int i = 0; i < len; i++) {
            for (int j = i; j < len; j++) {
                if (arr[j] < arr[i]) {
                    swap = arr[i];
                    arr[i] = arr[j];
                    arr[j] = swap;
                }
            }
        }
    }

    /**
     * 二分查找算法(循环)
     *
     * @param arr 目标数组
     * @param tag 查询目标值
     * @return tag在arr中的索引，未找到返回-1
     */
    public static int binarySearch(int[] arr, int tag) {
        int left = 0;
        int right = arr.length - 1;
        int middle;
        //循环条件若不加等号，会查询不到首尾数据
        while (left <= right) {
            middle = (right + left) / 2;
            System.out.println("left: " + left + "   right: " + right + "   middle: " + middle);
            if (tag == arr[middle]) {
                return middle;
            } else if (tag < arr[middle]) {
                right = middle - 1;
            } else {
                left = middle + 1;
            }
        }
        System.out.println("跳出循环： left: " + left + "   right: " + right);
        return -1;
    }

    /**
     * 二分查找算法(递归)
     *
     * @param arr   目标数组
     * @param tag   查询目标值
     * @param start 起始位置
     * @param end   结束位置
     * @return tag在arr中的索引，未找到返回-1
     */
    public static int binarySearch(int[] arr, int tag, int start, int end) {
        int middle = (start + end) / 2;
        if (tag < arr[start] || tag > arr[end] || start > end) {
            return -1;
        }
        if (tag < arr[middle]) {
            return binarySearch(arr, tag, start, middle - 1);
        } else if (tag > arr[middle]) {
            return binarySearch(arr, tag, middle + 1, end);
        } else {
            return middle;
        }
    }

    public static void main(String[] args) {
        int[] a = {1, 3, 2, 22, 4, 55, 21, 9, 10, 88, 12};
        bubble(a);
        System.out.println("冒泡排序后的数组： "+Arrays.toString(a));
        System.out.println("循环二分查找： " + binarySearch(a, 88));
        //end的值若超过数组下标长度，会抛出数组越界异常
        System.out.println("递归二分查找： " + binarySearch(a, 3, 0, a.length - 1));

    }
}

　　运行程序，输出的结果：

　　　　冒泡排序后的数组： [1, 2, 3, 4, 9, 10, 12, 21, 22, 55, 88]
　　　　left: 0   right: 10   middle: 5
　　　　left: 6   right: 10   middle: 8
　　　　left: 9   right: 10   middle: 9
　　　　left: 10   right: 10   middle: 10
　　　　循环二分查找： 10
　　　　递归二分查找： 2