数据结构和算法二分查找学习笔记

二分查找（Binary Search）算法

假设只有 10 个订单，订单金额分别是：8，11，19，23，27，33，45，55，67，98。现在要查找19元的订单。

每次都与区间的中间数据比对大小，缩小查找区间的范围。其中，low 和 high 表示待查找区间的下标，mid 表示待查找区间的中间元素下标

二分查找算法是针对有序数据集合的查找算法,也叫折半查找算法,二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想。每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0 。

package com.mayikt.linkedlistsource;

/**
 * 简单有序、不重复的有序集合进行二分查找
 *
 * @author zx
 * @date 2022年01月26日 9:10
 */
public class MainTestBinarySearch03 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
        showSearchValueIndex2(10, arr);

    }

    public static void showSearchValueIndex2(int value, int[] arr) {
        System.out.println("查找[" + value + "]的下标是:" + binarySearch(arr, value));
    }


    /**
     * 有序、不重复的数组使用二分查找对应数的下标
     *
     * @param arr   数组
     * @param value 需要查找的值
     * @return 查找数在数组中的下标位置
     */
    public static int binarySearch(int[] arr, int value) {
        //循环的次数记录器
        int i = 0;
        //低位下标
        int low = 0;
        //高位下标
        int high = arr.length - 1;

        while (low <= high) {
            i++;
            //中间的下标
            //int mid = (low + high) / 2;
            //使用位运算效率更高
            int mid = low + ((high - low) >> 1);
            if (arr[mid] == value) {
                System.out.println("拆分了[" + i + "]次才找到的数据");
                return mid;
            } else if (arr[mid] > value) {
                high = mid - 1;
            } else if (arr[mid] < value) {
                low = mid + 1;
            }
        }
        return -1;
    }
}

4.1.1.1 折半查找的优缺点

• 优点
  • 二分查找的时间复杂度是 O(logn)，查找数据的效率非常高。 n 、n/2、n/4、n/8、…. 、n/2^k 、…. ;经过了 k 次区间缩小操作，时间复杂度就是 O(k).通过 n/2k=1，我们可以求得 k=log2n，所以时间复杂度就是 O(logn)
• 缺点
  • 二分查找依赖顺序表结构,即就是数组；比如如果数据存储使用链表进行存储,那么是不可以使用二分查找。因为二分查找算法按照下标随机访问元素，此时的复杂度为O(1),而链表访问的复杂度为O(n),如果链表使用二分查找时间复杂度会变得更高。
  • 二分查找针对的是有序数据：如果数据没有序，我们需要先排序。排序的时间复杂度最低是 O(nlogn)，我们针对的是一组静态的数据，没有频繁地插入、删除，我们可以进行一次排序，多次二分查找。这样排序的成本可被均摊，二分查找的边际成本就会比较低。如果我们的数据集合有频繁的插入和删除操作，要想用二分查找，要么每次插入、删除操作之后保证数据仍然有序，要么在每次二分查找之前都先进行排序。针对这种动态数据集合，无论哪种方法，维护有序的成本都是很高的。针对动态变化的数据集合,二分查找将不再适用,会选择使用二叉树
  • **数据量太小不适合二分查找：**如果要处理的数据量很小，使用顺序遍历和二分查找他们的速度都差不多，只有数据量比较大的时候，二分查找的优势才会比较明显。如果数据之间的比较操作非常耗时，不管数据量大小，都推荐使用二分查找。比如，数组中存储的都是长度超过 300 的字符串，如此长的两个字符串之间比较大小，就会非常耗时。我们需要尽可能地减少比较次数，而比较次数的减少会大大提高性能，这个时候二分查找就比顺序遍历更有优势。
  • **数据量太大也不适合二分查找:**二分查找底层依赖数组这种数据结构，而数组在内存空间中必须是连续的，对内存要求是苛刻的。比如，我们有 1GB 大小的数据，如果希望用数组来存储，那就需要 1GB 的连续内存空间。如果没有连续的 1GB 大小的内存空间，那么是无法申请一个 1GB 大小的数组，二分查找依赖数组，太大数组进行存储就比较吃力，也就不能使用二分查找.

4.1.2 使用递归优化二分查找

package com.mayikt;

/**
 * 使用递归优化二分查找
 *
 * @author zx
 * @date 2022年01月26日 11:03
 */
public class MainTestDiguiBinarySearche {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21};
        printArray(arr);
        System.out.println(halfSearche(arr, 0, arr.length - 1, 1));
    }

    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println("arr[" + i + "]=" + arr[i]);
        }
    }
    
    /**
     * 折半查找
     *
     * @param arr       有序数组
     * @param lowIndex  低位索引
     * @param highIndex 高位索引
     * @param value     需要查找的数
     * @return 查找的元素在数组中的下标
     */
    private static int halfSearche(int[] arr, int lowIndex, int highIndex, int value) {
        if (lowIndex > highIndex) return -1;

        int mid = lowIndex + ((highIndex - lowIndex) >> 1);
        //找到数据了
        if (arr[mid] == value) return mid;
        //左折半
        if (arr[mid] > value) return halfSearche(arr, lowIndex, mid - 1, value);
        //右折半
        if (arr[mid] < value) return halfSearche(arr, mid + 1, highIndex, value);

        return -1;

    }
}

4.1.3 折半查找算法思考问题

假设我们有 1000 万个整数数据，每个数据占 8 个字节，如何设计数据结构和算法，快速判断某个整数是否出现在这 1000 万数据中？ 我们希望这个功能不要占用太多的内存空间，最多不要超过 100MB，你会怎么做呢？也就是说:如何在 1000 万个整数中快速查找某个整数？

分析:

• 我们的内存限制是 100MB，每个数据大小是 8 字节,占用内存大约为80M
• 最简单的办法就是将数据存储在数组。
• 先对这 1000 万数据从小到大排序，然后再利用二分查找算法.[二分查找适合静态数据集合(有序数据集合)]

散列表、二叉树支持动态数据结构，这两种算法在进行比较的时候需要额外的内存空间。在这里的场景中内存限制为100M，所有在这里不适合。