二分查找算法解析

二分算法：

二分查找的步骤描述：
概述：有序数组中查找关键字的所在位置

• 1、首先要确定整个查找区间的中间位置，
• 2、用待查关键自key值与中间值进行对比
  • 相等：则返回中间值下标
  • 若大于，则在中间值的后半部分进行查找
  • 若小于，则在中间值得前半部分进行查找
  • 每次折半查找，重复以上步骤

一、非递归二分查找算法（用while循环判断）

非递归的实现就在于，查找中间值和需要查找的值进行对比，如果不想等，修改中间值得位置，重复，直到找到返回下标，或左右重合，返回-1.

/**
 * 二分查找算法（非递归）
 * @Created by li on 2020/8/28    14:55.
 */
public class BinarySearchNoRecur {
    public static void main(String[] args) {
        int[] arr = new int[]{1,3,8,10,11,67,100};
        int i = binarySearch(arr, 1);
        System.out.println("i:"+i);
    }
    //二分查找的非递归实现
    /**
     * @param arr 待查找的数组
     * @param target 需要查找的数
     *
     * @return 返回对应的下标，-1代表没有找到
     */
    public static int binarySearch(int[] arr,int target){
        int left =0;
        int right =arr.length-1;
        while (right>=left){
        int mid = (right+left)/2;
            if(arr[mid]==target){
                return mid;
            }else if(arr[mid]>target){
                right = mid-1;
            }else if(arr[mid]<target){
                left = mid+1;
            }
        }
        return -1;
    }
}

二、递归的二分查找算法

递归实现二分查找，如果本次没有找到，就进行递归下一次查找，在查找之前修改mid的值
查到到一个就返回

 /**
     * 二分查找，
     * 返回元素第一次出现的位置
     *
     * @param arr   数组
     * @param num   需要查找的元素
     * @param left  查找的左边的位置
     * @param right 查找的右边的位置
     * @return 如果找到元素，就将其下标返回，没有找到就返回-1；
     */
    public int Binarysearch(int[] arr, int num, int left, int right) {
        if(num>arr[right] || num<arr[left])
            return -1;

        if (left >= right) {
            return -1;
        }
        int mid = left + (right - left) * (num - arr[left]) / (arr[right] - arr[left]);
        if (num == arr[mid]) {
            return mid;

        } else if (num > arr[mid]) {
            return Binarysearch(arr, num, mid + 1, right);
        } else {
            return Binarysearch(arr, num, left, mid);
        }
    }

查到元素的所有位置：

  /**
     * 二分查找，
     * 返回元素所有的位置
     * @param arr   数组
     * @param num   需要查找的元素
     * @param left  查找的左边的位置
     * @param right 查找的右边的位置
     * @return 如果找到元素，就将其下标返回，没有找到就返回-1；
     */

    public List<Integer> Binarysearch1(int[] arr, int num, int left, int right) {
        if(num>arr[right] || num<arr[left])
            return new ArrayList<>();
        if (left >= right) {
            return new ArrayList<>();
        }

        int mid = left + (right - left) * (num - arr[left]) / (arr[right] - arr[left]);
//        int mid = (left+right)/2;
        if (num == arr[mid]) {
            List<Integer> list = new ArrayList<>();
            int t = mid - 1;
            while (arr[t] == num && t > 0) {
                list.add(t);
                t--;
            }
            list.add(mid);
            int m = mid + 1;
            while (arr[m] == num && m < arr.length) {
                list.add(m);
                m++;
            }
            return list;
        } else if (num > arr[mid]) {
            return Binarysearch1(arr, num, mid + 1, right);
        } else {
            return Binarysearch1(arr, num, left, mid);
        }
    }

时间复杂度：O(log2n)