二分查找算法（有序数组）

只适用于有序数组哦！！！

二分查找,顾名思义就是将数组对半分开进行查找

package search;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 二分查找法
 * 数组必须有序
 */
public class BinarySeatch {

    public static void main(String[] args) {
        int[] arr = {1,1,1,1, 5, 8, 9, 10, 44, 44, 44, 223};
        int index = binarysearch(arr, 0, arr.length - 1, 1);
//        System.out.println(index);

        int[] sub = binarysearchpuls(arr, 0, arr.length - 1, 1);
        System.out.println(Arrays.toString(sub));

        ArrayList<Integer> lists=binarysearch2(arr,0,arr.length-1,1);
        System.out.println(lists);
    }

    /**
     * 二分查找法
     * 只能找一个数
     *
     * @param arr
     * @param left      左边的索引
     * @param right     右边的索引
     * @param findvalue 要查找的值
     * @return 如果找到就返回下标，如果没有找到，就返回-1
     */
    public static int binarysearch(int arr[], int left, int right, int findvalue) {
        int mid = (left + right) / 2; //获取中间基数的下边
        int midvalue = arr[mid];      //获取中间数的值
        //当left 》 right时，说明递归整个数组都没有找到，变成死龟
        if (left > right) {
            return -1;
        }

        if (findvalue > midvalue) {//向右递归
            return binarysearch(arr, mid + 1, right, findvalue);
        } else if (findvalue < midvalue) {//向左递归
            return binarysearch(arr, left, mid - 1, findvalue);
        } else {
            return mid;
        }
    }

    /**
     * 二分查找法升级版 （可以查找到所有值一样的数） 也是需要有序的噢
     * 因为数组本来就是有序的，所以只要我们找到一个，那么我们接下来就分别从它的左边和右边开始查找
     *
     * @param arr
     * @param left
     * @param right
     * @param findvalue
     * @return
     */
    public static int[] binarysearchpuls(int arr[], int left, int right, int findvalue) {
        int index = binarysearch(arr, left, right, findvalue);
        int count = 0;
        int sub[] = new int[arr.length];//用来存放下标
        int leftindex = index;   //用来遍历左边
        int rightindex = index + 1;  //用来遍历右边
        while (leftindex >= 0 && arr[leftindex] == arr[index]) {
//            System.out.println(leftindex);
            sub[count++] = leftindex;
            leftindex--;
        }
        while (rightindex <= arr.length - 1 && arr[rightindex] == arr[index]) {
//            System.out.println(rightindex);
            sub[count++] = rightindex;
            rightindex++;

        }
        return sub;

    }

    public static ArrayList<Integer> binarysearch2(int arr[], int left, int right, int findvalue) {
        int mid = (left + right) / 2; //获取中间基数的下边
        int midvalue = arr[mid];      //获取中间数的值
        //当left 》 right时，说明递归整个数组都没有找到，变成死龟
        if (left > right) {
            return new ArrayList<Integer>();
        }

        if (findvalue > midvalue) {//向右递归
            return binarysearch2(arr, mid + 1, right, findvalue);
        } else if (findvalue < midvalue) {//向左递归
            return binarysearch2(arr, left, mid - 1, findvalue);
        } else {

            ArrayList<Integer> reindexlist = new ArrayList<Integer>();
            //向mid索引值的左边扫描，将所有满足1000的元素的下标加入到list中
            int temp = mid - 1;
            while (true) {
                if (temp < 0 || arr[temp] != findvalue) {
                    //退出
                    break;
                }
                //否则
                reindexlist.add(temp);
                temp--;
            }
            reindexlist.add(mid);
            //向mid右边扫描
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 || arr[temp] != findvalue) {
                    //退出
                    break;
                }
                //否则
                reindexlist.add(temp);
                temp++;
            }
            return reindexlist;
        }
    }
}

由于原方法查找到一个数据就结束掉，不能查找多个数据
所以我进行了升级
后面的两个方法是对原方法的升级版