查找算法：二分查找算法

二分查找介绍

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
前提：必须有序

1.普通二分查找（只找出一个目标值）

1.1整体思路

/**1.每次对检索区域的中间位置值（mid），与要查找的val进行比较；
     * 2.如果中间值等于检索值val，则返回此时对应的下标mid;
     * 3.如果中间值大于检索值val,则对原范围的中间值前面的部分，再次进行二分检索（返回这部分二分查找结果），（即递归思想）；
     * 此时，左边界下标不变，右边界下标为mid-1；递归调用二分查找；
     * 4.如果中间值小于检索值val,则对原范围的中间值后面的部分，再次进行二分检索（返回这部分二分查找结果），（即递归思想）；
     * 此时，右边界下标不变，左边界下标为mid+1；递归调用二分查找；
     * 5.步骤3、4递归过程不断缩小检索范围，寻找val位置，
     * 5.1直到找到val值，即满足步骤2时返回，递归结束；
     * 5.2或者等到 left>right时，说明未找到；
     * (因为每次递归不是左边界会向右移，就是右边界向左移，当相等的时候是最后一次判断，之后就会left>right，已全部检索完毕，并且未找到val）
     * @param arr 被搜索的有序数组
     * @param left 搜索范围左指针（左边界下标）
     * @param right 搜索范围右指针（右边界下标）
     * @param val 检索的值
     * @return
     */

1.2代码实现

 private static int myBinarySearch(int[] arr, int left, int right, int val) {
        int mid=(left+right)/2;
        if (left>right){
            return -1;//返回-1 说明没找到，检索数组中没有这个检索值
        }

        if (arr[mid]==val){//步骤2.如果中间值等于检索值val，则返回此时对应的下标mid;
            return mid;
        }else if (arr[mid]>val){
            //步骤3.如果中间值大于检索值val,则对原范围的中间值前面的部分，再次进行二分检索，（即递归思想）；此时，左边界下标不变，右边界下标为mid-1；递归调用二分查找；
            return myBinarySearch(arr,left,mid-1,val);
        }else return myBinarySearch(arr,mid+1,right,val);//步骤4.如果中间值小于检索值val,则对原范围的中间值后面的部分，再次进行二分检索，（即递归思想）；

    }

1.3测试

  public static void main(String[] args) {
        int[] arr=new int[]{1,2,3,4,5};
        System.out.println("原数组："+Arrays.toString(arr));

        int key=myBinarySearch(arr,0,4,9);
        System.out.println("下标检索值9得下标（-1为未找到）："+key);

        int key2=myBinarySearch(arr,0,4,4);
        System.out.println("下标检索值4得下标（-1为未找到）："+key2);

    }

结果：

2 二分查找（找出所有目标值）

我们检索的对象中可能不止一个目标值，需要将他们全部检索出；
如：{1,2，2，2,3，4,5}
查找2时，需要将所有值为2的元素找出；返回一个下标的数组；

2.1思路

1）依然用二分思想，只不过找到目标值后，不返回mid下标；
2）而是开始向mid前面一个个检索判断是否为val；再向后面检索；
3）每个方向发现不等于val时停止，或者越界停止；

2.2代码实现

//返回值是一个集合，结果无论多少就放进集合里；
private static ArrayList<Integer> myBinarySearch2(int[] arr, int left, int right, int val) {

        int mid = (left + right) / 2;
        if (left > right) {
            ArrayList arrayList=new ArrayList(1);//就放1个值，初始空间小点；
            arrayList.add(-1);//返回-1 说明没找到，检索数组中没有这个检索值
            return arrayList;
        }

        if (arr[mid] == val) {//如果中间值等于检索值val，此时找到了mid; 向前后分别检索，得到结果数组并返回；
            ArrayList result = new ArrayList();
            int le = mid - 1;//定义个左指针不断向左检索
            while (le >= 0 && arr[le] == val) {//只要没越界，值相等，就不断向左找；
                result.add(le);//没停止说明值是val，将下标加入要返回的集合中；
                le -= 1;//左侧指针继续向左移动；
            }
            //出了循环说明mid左边找完了，将mid加入返回的集合
            result.add(mid);
            //接着找右边
            int ri = mid + 1;
            while (ri < arr.length - 1 && arr[ri] == val) {
                result.add(ri);//没停止说明值是val，将下标加入要返回的集合中；
                ri += 1;//右侧指针，继续向右移动；
            }

            //至此均以检索完，返回集合；
            return result;

        } else if (arr[mid] > val) {
            //如果中间值大于检索值val,则对原范围的中间值前面的部分，再次进行二分检索，（即递归思想）；此时，左边界下标不变，右边界下标为mid-1；递归调用二分查找；
            return myBinarySearch2(arr, left, mid - 1, val);
        } else return myBinarySearch2(arr, mid + 1, right, val);//如果中间值小于检索值val,则对原范围的中间值后面的部分，再次进行二分检索，（即递归思想）；

    }

2.3测试

 public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 2,2,2,2,3,3,3,3, 4, 5};
        System.out.println("原数组：" + Arrays.toString(arr));

        ArrayList keyA = myBinarySearch2(arr, 0, 4, 9);
        System.out.println("下标检索值9得下标（-1为未找到）：" + keyA);

        ArrayList keyA2 = myBinarySearch2(arr, 0, 4, 2);
        System.out.println("下标检索值2得下标（-1为未找到）：" + keyA2);

    }

结果：