数据结构和算法:二分查找

二分查找

二分查找的思想

二分查找(Binary Search)算法,也叫折半查找算法。

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

假设有1000条订单数据,已经按照订单金额从小到大排序,每个订单都不同,并且最小单位是元。现在想知道是否存在金额等于19元的订单。如果存在,则返回订单数据,如果不存在则返回null。

利用二分思想,每次都与区间的中间数据比对大小,缩小查找区间的范围。下图中,low和high表示待查找区间的下标,mid表示待查找区间的中间元素下标。

在这里插入图片描述

二分查找的时间复杂度为O(logn),被查找区间的大小变化:
n, n / 2, n / 4, n / 8, ..., n / (2^k), ...

二分查找的实现

最简单的情况就是有序数组中不存在重复元素,java代码循环实现:

public int bsearch(int[] arr, int n, int value){
    int low = 0;
    int high = n - 1;
    while(low <= high){
        int mid = (low + high) / 2;
        if (arr[mid] == value){
            return mid;
        } else if (arr[mid] < value){
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return -1;
}

low、high、mid都是指数组下标,其中low和high表示当前查找的区间范围,初始low = 0,high = n - 1。mid表示[low, high]的中间位置。我们通过对比arr[mid]与value的大小,来更新接下来要查找的区间范围,知道找到或者区间缩小为0,就退出。

需要注意的点:

  1. 循环退出条件是low <= high,而不是low < high。

  2. mid = (low + high) / 2这种写法,在low和high比较大时,两者之和可能会溢出。

改进的方法是将mid的计算方式写成low + (high - low) / 2,转化成位运算(low + (high - low) >> 1)更佳。

3.写成low = mid或者high = mid,可能会发生死循环。应当写成low = mid + 1,high = mid - 1。

二分查找的java递归实现:

public int bsearch(int[] arr, int n, int val){
    return bsearchInternally(arr, 0, n - 1, val);
}
private int bsearchInternally(int[] arr, int low, int high, int value){
    if (low > high){
        return -1;
    }
    int mid = low + ((high - low) >> 1);
    if (arr[mid] == value){
        return mid;
    } else if (arr[mid] < value){
        return bsearchInternally(arr, mid + 1, high, value);
    } else {
        return bsearchInternally(arr, low, mid - 1, value);
    }
}

二分查找应用场景的局限性

1.二分查找依赖的是顺序表结构,即数组

二分查找算法需要按照下标随机访问元素,所以不能用链表随机访问的时间复杂度是O(n)。所以,如果数据使用链表存储,二分查找的时间复杂度就会变得很高。

二分查找只能用在数据是通过顺序表来存储的数据结构上。如果你的数据是通过其他数据结构存储的,则无法应用二分查找。

2.二分查找要求数据必须是有序的,或者无序但没有频繁的插入和删除操作

数据没有序,进行一次排序,多次二分查找。这样排序的成本可被均摊,二分查找的边际成本就会比较低。

但如果数据集合有频繁的插入和删除操作,要想用二分查找,要么每次插入、删除操作之后保证数据仍然有序,要么在每次二分查找之前都先进行排序。针对这种动态数据集合,无论哪种方法,维护有序的成本都是很高的。

所以,二分查找只能用在插入、删除操作不频繁,一次排序多次查找的场景中。

3.数据量太小查找性能提升不大

但如果数据之间的比较操作非常耗时,比较次数的减少会大大提高性能,这个时候二分查找就比较顺序遍历更有优势。

4.数据量太大不适合二分查找

只有数据量比较大的时候,二分查找的优势才会比较明显。

不过,这里有一个例外。如果数据之间的比较操作非常耗时,不管数据量大小,都推荐使用二分查找。比如,数组中存储的都是长度超过300的字符串,如此长的两个字符之间比对大小,就会非常耗时。我们需要尽可能地减少比较次数,而比较次数的减少会大大提高性能,这个时候二分查找就比顺序遍历更有优势。

二分查找的底层需要依赖数组这种数据结构,而数组为了支持随机访问的特性,要求内存空间连续,对内存的要求比较苛刻。比如有1G大小的数据,用数组来存储,就有需要1G的连续内存空间。

“连续”意味着即便有2G的内存空间剩余,但是如果这剩余的2G内存空间都是零散的,没有连续的1G大小的内存空间,那就无法申请一个1G大小的数组。

二分查找的三种变体

变体一:查找第一个值等于给定值的元素

如果有序数据集合中存在重复的数据,要找到第一个值等于给定值的数据。

比如下面这样一个有序数组,其中,a[5], a[6], a[7]的值都等于8,是重复的数据。我们希望查找第一个等于8的数据,也就是下标是5的元素。

在这里插入图片描述

简洁实现:

public int bsearch(int[] arr, int n, int value){
    int low = 0;
    int high = n - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if (arr[mid] >= value){
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    if (low < n && arr[low] == value){
        return low;
    } else {
        return -1;
    }
}

容易理解的java实现:

public int bsearch(int[] arr, int n, int value){
    int low = 0;
    int high = n - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if (arr[mid] > value){
            high = mid - 1;
        } else if (arr[mid] < value){
            low = mid + 1;
        } else {
            if ((mid == 0) || (arr[mid - 1] != value)){
                return mid;
            } else {
                high = mid - 1;
            }
        }
    }
    return -1;
}

求解的是第一个值等于给定值的元素,当arr[mid]等于要查找的值,就需要确认一下这个arr[mid]是不是第一个值等于给定值的元素。

如果mid等于0,那这个元素已经是数组的第一个元素,那它肯定是我们要找的;

如果mid不等于0,但arr[mid]的前一个元素arr[mid - 1]不等于value,那也说明arr[mid]就是要找的第一个值等于给定值的元素。

如果经过检查之后发现arr[mid]前面的一个元素arr[mid - 1]也等于value,那说明此时的arr[mid]肯定不是要查找的第一个值等于给定值的元素。那就更新high = mid - 1,因为要找的元素肯定出现在[low, mid - 1]之间。

变体二:查找最后一个值等于给定值的元素

java实现:

public int bsearch(int[] arr, int n, int value){
    int low = 0;
    int high = n - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if (arr[mid] > value){
            high = mid - 1;
        } else if (arr[mid] < value){
            low = mid + 1;
        } else {
            if ((mid == n - 1) || (arr[mid + 1] != value)){
                return mid;
            } else {
                low = mid + 1;
            }
        }
    }
}

如果arr[mid]这个元素已经是数组中的最后一个元素了,那它肯定是我们要找的;

如果arr[mid]的后一个元素arr[mid + 1]不等于value,那也说明arr[mid]就是我们要找的最后一个值等于给定值的元素。

如果arr[mid]后面的一个元素arr[mid + 1]也等于value,那说明当前的这个arr[mid]并不是最后一个值等于给定值的元素。我们就更新low = mid + 1,因为要找的元素肯定出现在[mid + 1, high]之间。

变体三:查找第一个大于等于给定值的元素

java代码实现:

public int bsearch(int[] arr, int n, int value){
    int low = 0;
    int high = n - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if (arr[mid] >= value){
            if ((mid == 0) || (arr[mid - 1] < value)) {
                return mid;
            } else {
                high = mid - 1;
            }
        } else {
            low = mid + 1;
        }
    }
    return -1;
}

如果arr[mid]小于要查找的值value,那要查找的值肯定在[mid + 1, high]之间,更新low = high + 1。

对于arr[mid]大于等于给定值value的情况,如果arr[mid]前面已经没有元素,或者前面一个元素arr[mid - 1]小于要查找的值value,那arr[mid]就是目标元素。

如果arr[mid - 1]也大于等于要查找的值value,那说明要查找的元素在[low, mid - 1]之间,所以,将high更新为mid - 1。

变体四:查找最后一个小于等于给定值的元素

java代码实现:

public int bsearch(int[] arr, int n, int value){
    int low = 0;
    int high = n - 1;
    while(low <= high){
        int mid = low + ((high - low) >> 1);
        if (arr[mid] > value){
            high = mid - 1;
        } else {
            if ((mid == n - 1) || (arr[mid + 1] > value)){
                return mid;
            } else {
                low = mid + 1;
            }
        }
    }
    return -1;
}

二分查找相关问题

如何快速判断某个整数是否出现在这1000万数据中?

假设有1000万个整数,每个数据占8个字节,内存限制是100MB,如何设计数据结构和算法,快速判断某个整数是否出现在者1000万数据中

每个数据大小是8字节,将数据存储在数组中,内存占用差不多是80MB,符合内存的限制。对这1000万数据利用原地排序算法排序,然后再利用二分查找算法,就可以快速地查找想要的数据了。

用二分查找求一个数的平方根

如何编程实现“求一个数据的平方根”?要求精确到小数点后6位。
python代码实现:

def bsearch_sqrt(num: float) -> float:
    if num < 0
        raise ValueError
    if num ** 2 == num:
        return num
    if num < 1:
        low, high = num, 1
    else:
        low, high = 0, num
    while high - low > 0.0000001:
        mid = (high + low) / 2
        mid_v2 = mid ** 2
        if mid_v2 > num:
            high = mid
        elif mid_v2 < num:
            low = mid
        elif mid_v2 == num:
            return mid
    return round((high + low) / 2, 6)

二分查找快速定位IP对应的省份地址

IP地址查找IP归属地是通过维护一个很大的IP地址库来实现的。地址库中包括IP地址范围和归属地的对应关系。

当查询202.102.133.13这个IP地址的归属地时,就在地址库中搜索,发现这个IP地址落在[202.102.133.0,202.102.133.255]这个地址范围内,那我们就可以将这个IP地址范围对应的归属地“山东东营市”显示给用户了。

202.102.133.0|202.102.133.63|山东东营联通
202.102.133.64|202.102.133.255|山东济南联通
202.102.134.0|202.102.134.255|山东青岛联通
202.102.135.0|202.102.135.231|山东烟台联通
202.102.48.0|202.102.48.255|江苏宿迁电信
202.102.49.0|202.102.49.255|江苏泰州电信
202.102.50.0|202.102.50.255|江苏苏州电信
202.102.51.0|202.102.101.255|江苏南京电信

假设有12万条这样的IP区间与归属地的对应关系,如何快速定位出一个IP地址的归属地呢

思路:
可以先预处理这12万条数据,存储在数组中,让其按照起始IP(按照地址对应的整型值)从小到大排序。

查询某个IP归属地时,先通过二分查找找到最后一个起始IP小于等于这个IP的IP区间,然后检查这个IP是否在这个IP区间内,如果在就取出对应的归属地显示;如果不在就返回未查找到。

代码实现:

ip_rule_list = []
with open("ip.txt", encoding = "utf-8") as f:
    for line in f:
        start_ip, end_ip, location = line.rstrp().split("|", 2)
        ip_rule_list.append((start_ip, end_ip, location))
def ip2int(ip_str: str) -> int:
    result = 0
    for i in ip_str.split(",")
        result = (result << 8) + int(i)
    return result
ip_rule_list.sort(key = lambda x: ip2int(x[0]))
def ip_to_location(ip: str) -> str:
    low, high = 0, len(ip_rule_list) - 1
    ip_int = ip2int(ip)
    while low <= high:
        mid = (low + high) >> 1
        #查找最后一个起始IP小于等于这个IP的区间
        if ip2int(ip_rule_list[mid][0]) < ip_int:
            low = mid + 1
        else:
            high = mid - 1
    if high >= 0 and ip2int(ip_rule_list[high][0] <= ip_int <= ip2int(ip_rule_list[high][1])):
        return ip_rule_list[high][2]
    else:
        return ""

循环有序数组的二分查找问题

如果有序数组是一个循环有序数组,比如4、5、6、1、2、3。针对这种情况,如何实现一个求“值等于给定值”的二分查找算法呢?

思路:
对于数组[1,2,3,4,5,6]共有下列6中旋转方法:
1  2  3  4  5  6

6  1  2  3  4  5

5  6  1  2  3  4

4  5  6  1  2  3

3  4  5  6  1  2

2  3  4  5  6  1

以数组中间点为分区,会将数组分成升序和非升序两部分。

由此可得:

  • 若中间数小于最右边数,则右半段是升序区间
  • 若中间数大于最右边数,则左半段是升序区间

然后根据目标值是否存在与升序区间,确定保留哪一区间,进行二分查找即可

python代码实现:

def binary_search_circle_array(arr: list, value) -> int:
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) >> 1
        if arr[mid] < arr[high]: return mid
        # 上面没有返回,说明中间值不是目标值
        if arr[mid] < arr[high]: # 若中间数小于最右边数,则右半段是升序区间
            if arr[mid] < value and value <= arr[high]: # 在右半段有序区间
                low = mid + 1
            else:
                high = mid - 1
        elif arr[mid] > arr[high]: # 若中间数大于最右边数,则左半段是升序区间
            if arr[low] <= value and value < arr[mid]: # 在左半段有序区间
                high = mid - 1
            else:
                low = mid + 1
        else: # 若中间数等于最右边数,则目标不在右半段
            low = mid + 1
    return -1
  • 5
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

辣椒种子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值