java实现二分查找（折半查找）的算法

java实现二分查找的算法

二分查找 又叫折半查找，是一种简单又快速的查找算法。它对要查找的序列有两个要求：一是该序列必须是有序的（即该序列中的所有元素都是按照大小关系排好序的，升序和降序都可以，本文假设是升序排列的），二是该序列必须是顺序存储的。

二分查找算法的原理如下：

1. 如果待查序列为空，那么就返回-1，并退出算法；这表示查找不到目标元素。

2. 如果待查序列不为空，则将它的中间元素与要查找的目标元素进行匹配，看它们是否相等。

3. 如果相等，则返回该中间元素的索引，并退出算法；此时就查找成功了。

4. 如果不相等，就再比较这两个元素的大小。

5. 如果该中间元素大于目标元素，那么就将当前序列的前半部分作为新的待查序列；这是因为后半部分的所有元素都大于目标元素，它们全都被排除了。

6. 如果该中间元素小于目标元素，那么就将当前序列的后半部分作为新的待查序列；这是因为前半部分的所有元素都小于目标元素，它们全都被排除了。

7. 在新的待查序列上重新开始第1步的工作。

二分查找之所以快速，是因为它在匹配不成功的时候，每次都能排除剩余元素中一半的元素。因此可能包含目标元素的有效范围就收缩得很快，而不像顺序查找那样，每次仅能排除一个元素。

java代码实现：

//二分查找的算法（必须是有序的 数组才可以 使用二分查找）
public class BinarySearch {
    public static void main(String[] args) {

//        int[] arr={-10,-1,5,10,32,56};
//        int result = binarySearch(arr, 0, arr.length-1, 56);
//        if (result!=-1){
//            System.out.printf("该数的下标为：%d ",result);
//        }else{
//            System.out.println("没有找到该数据");
//        }


        int[] arr = {-10, -1, 5, 10, 10, 10, 10, 10, 32, 56};
        ArrayList<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 10);
        if (resIndexList.size() != 0) {
            System.out.println("该数的下标为：" + resIndexList);
        } else {
            System.out.println("没有找到该数。");
        }

    }


    /**
     * @param arr     待查找的数组
     * @param left    数组的左边 从哪里开始查找
     * @param right   数组的右边
     * @param findval 待查找的值
     * @return 找到的话返回 对应的数组下标，如果没有找到返回-1.
     */
    public static int binarySearch(int[] arr, int left, int right, int findval) {

        int mid = (left + right) / 2;
        int find = arr[mid];

        if (left > right) {
            return -1;
        }

        //不用递归法
//        while(left<=right){
//            if (findval<find){
//                right=mid-1;
//                mid=(left+right)/2;
//                find = arr[mid];
//            }else if(findval>find){
//                left=mid+1;
//                mid=(left+right)/2;
//                find = arr[mid];
//            }else {
//                return mid;
//            }
//        }
//        return -1;

        //利用递归法
        if (findval < find) {
            return binarySearch(arr, left, mid - 1, findval);
        } else if (findval > find) {
            return binarySearch(arr, mid + 1, right, findval);
        } else {
            return mid;
        }
    }

    //二分查找的拓展 ， 如果有相同的元素，就一起返回它的下标
    public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findval) {

        int mid = (left + right) / 2;
        int find = arr[mid];

        if (left > right) {
            return new ArrayList<>();
        }

        if (findval < find) {
            return binarySearch2(arr, left, mid - 1, findval);
        } else if (findval > find) {
            return binarySearch2(arr, mid + 1, right, findval);
        } else {
            ArrayList<Integer> resList = new ArrayList<>();
            int temp = mid - 1;
            while (true) {
                if (temp < 0 || arr[temp] != findval) {
                    break;
                }
                resList.add(temp);
                temp -= 1;
            }
            resList.add(mid);
            temp = mid + 1;
            while (true) {
                if (temp > right || arr[temp] != findval) {
                    break;
                }
                resList.add(temp);
                temp += 1;
            }
            return resList;
        }
    }
    
}