数组中的二分法查找

二分法查找：
第一：二分法中查找建立在排序的基础之上。
第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
第三：二分查找法原理？
10（0下标） 23 56 89 100 111 222 235 500 600
目标：找出600下标
(0 + 9) / 2 --> 4（中间元素的下标）

arr[4]这个元素就是中间元素：arr[4]是100
100 < 600
说明被查找的元素在100的右边。
那么此时开始下标变成：4 + 1

（5 + 9） / 2 --> 7 （中间元素的下标）
arr[7] 对应的是：235
235 < 600
说明被查找的元素在235的右边。

开始下标又进行了转变：7 + 1
(8 + 9) / 2 --> 8
arr[8] --> 500
500 < 600
开始元素的下标又发生了变化：8 + 1
（9 + 9） / 2 --> 9
arr[9]是600，正好和600相等，此时找到了。

不用二分法查找案例：

package com.javaSe.Arrays;
/*
数组的元素查找：
    数组元素查找有两种方式：
        第一种方式：一个一个挨着找，直到找到为止。
        第二种方式：二分法查找（算法）。这个效率高。
 */
public class ArraysSearch {
    public static void main(String[] args) {
        // 这个例子演示一下第一种方式
        int[] arr = {4,5,6,87,8};
        
        // 需求：找出87的下标。如果没有返回-1
        /*for (int i = 0; i < arr.length;i++){
            if(arr[i] == 87){
                System.out.println("元素87的下标是：" + i);
                return;
            }
        }
        
        // 程序执行到此处，表示没有87
        System.out.println("不存在87的元素");*/
        
        // 最后以上的程序封装一个方法，思考：传什么参数？返回什么值？
        // 传什么：第一个参数是数组，第二个参数是被查找的元素。
        // 返回值：返回被查找的这个元素的下标。如果找不到返回-1。
        int index = arraySearch(arr,87);
        System.out.println(index == -1 ? "该元素不存在" : "该元素下标是:" + index);
    }
    
    /**
     * 从数组中检索某个元素的下标
     * @param arr 被检索的数组
     * @param i 被检索的元素
     * @return 大于等于0的数表示元素的下标。-1表示该元素不存在。
     */
    public static int arraySearch(int[] arr, int i) {
        for (int j = 0; j < arr.length; j++) {
            if (i == arr[j]){
                return j;
            }
        }
        return -1;
    }
}

模拟java.util.Arrays;中的二分法查找案例：

package com.javaSe.Arrays;
/*
1 数组工具类：自己写的。不是SUN的
2 关于查找算法中的：二分法查找。
    10（下标0） 11 12 13 14 15 16 17 18 19 20（下标10） arr数组
    通过二分法查找，找出18这个元素的下标。
        (0 + 10) / 2 --> 中间元素下标是5
        
    拿着中间这个元素和目标要查找的元素进行对比：
        中间元素是arr[5] arr[5] --> 15
        15 < 18(被查找的元素)
        被查找的元素18目前中间元素15的右边。
        所以开始元素的下标从0变成5 + 1
        
    在重新计算一个中间元素的下标：
        开始下标是： 5 + 1
        结束下标是:10
        (6 + 10) / 2 --> 8
        
    8下标对应的元素arr[8]是18
        找到的中间元素正好和被找的元素18相等。
        
    二分法查找的种植条件：一直折半，直到中间的那个元素恰好是被查找的元素。
        
3 二分法查找算法是基于排序的基础之上。（没有排序的数据是无法查找的）

 */
public class ArraysUtil {
    public static void main(String[] args) {
        int[] arr = {111,222,333,444,555,666,777,888,999};
        
        // 找出arr这个数组汇总200所在的下标。
        // 调用方法
        int index = binarySearch2(arr,222);
        System.out.println(index == -1 ? "该元素不存在！" : "该元素的下标是：" + index);
    }
    
    /**
     * 从数组中查找目标元素的下标
     * @param arr 被查找的数组（这个必须是已经排序的。）
     * @param dest 目标元素
     * @return -1表示该元素不存在，其它表示返回该元素的下标。
     */
    public static int binarySearch2(int[] arr, int dest) {
        // 开始下标
        int begin = 0;
        // 结束下标
        int end = arr.length - 1;
        
        // 开始元素的下标只要在结束元素下标的左边，就有机会继续循环。
        while (begin <= end) {
            // 中间元素下标
            int mid = (begin + end) / 2;
        
            if (arr[mid] == dest) {
                return mid;
            } else if (arr[mid] < dest) {
                // 目标在“中间”的右边
                // 开始元素下标需要发生变化(开始元素的下标需要重新赋值)
                begin = mid + 1;// 一直增
            } else {
                // arr[mid] > dest
                // 目标在“中间”的左边
                // 修改结束元素的下标
                end = mid - 1;// 一直减
            }
        }
            return -1;
    }
}