【数据结构与算法】顺序查找、折半查找、分块查找

顺序查找

顺序查找，又叫线性查找。适用于线性表。它的核心思路是从线性表的一端开始，逐个检查关键字是否满足给定条件。若满足条件，则返回下标。若已经查找到了线性表的另一端，但还没有找到符合给定条件的元素，则返回查找失败。

简述就是，从头到尾扫一遍，有要找的元素就返回下标，没有就返回没有

实现

// C++

struct List
{
    int len;
    int *items;
};

int find(List &list, int aim){
    for(int i = 0; i< list.len; i++){
        if(aim == list.items[i]) return i;
    }
    return -1;
}

对于顺序查找来说，它的执行时间与线性表的长度 n 有关，时间复杂度为 O(n)，空间复杂度为 O(1)。

假设使用顺序查找，查找元素在长度为 n 线性表中的位序为 i。那么找到这个元素需要进行 n - i + 1 次关键字的比较。即 $C_i=n-i+1$

那么查找成功时，顺序查找的平均查找长度为 $ASL={\sum }_{i=1}^n{P}_i{C}_i={\sum }_{i=1}^n{P}_i(n-i+1)$

若每个元素查找的概率$P_i$相同，即$P_i=1/n$时，有$ASL=(n+1)/2$。

查找不成功时，平均查找长度为 n + 1。

对有序表的顺序查找

如果一个线性表是有序的，那么我们就可以通过比较来提前终止查找，而不是一定要从头到尾扫一遍线性表。

例如：

• 如果查找元素小于两端元素或大于两端元素，那么我们可以直接返回失败。因为查找元素在线性表元素区间之外。
• 在查找的过程中，找到了一个比待查找元素大的元素（按从小到大到的顺序遍历）或找到了一个比待查找元素小的元素（按从大到小的顺序遍历），也可以直接返回。

二分查找（折半查找）

二分查找是在对有序表的顺序查找上进行了扩展，但是只适用于适用顺序存储结构的线性表。因为链式结构的线性表无法在 O(1)的时间内读取到元素。

二分查找的核心思路是，不断地划分区间，直至找到元素或区间不可再划分。

例如：

假设我们在有序顺序表 1 3 5 7 9 11 13 15 中查找元素 3。

那么第一次，判断中位数与关键字的大小，中位数为 7（共有 8 个元素，元素下标为 0 到 7，因为计算机中两个整形数相除还是整形数，可能会丢失精度，所以中位数的下标为 $(0+7)/2=3$，3 号位上的元素为 7），3 比 7 小，所以在下标为[0, 3)这个区间内查找，即在[0,2]区间内查找。

第二次，判断中位数与关键字的大小，中位数的位序为$(0+2)/2=1$，1 位序上的数为 3，等于查找元素。直接返回位序 1。

实现

int binary_search(List &list, int aim)
{
    int left = 0, right = list.len - 1; // 初始的左右区间
    int mid;                            // 中位数

    while (left <= right)
    {
        mid = (left + right) >> 1; // 右移一位，等于（left + right）/2
        if (list.items[mid] == aim)
            return mid;
        else if (list.items[mid] > mid)
            right = mid - 1;
        else
            left = mid + 1;
    }
}

如果使用的是 C++且不想自己手写二分，那么可以直接用 C++标准库中提供的二分函数。（对于考研人来说还是不要用了，因为不能保证改卷老师知道 C++标准库里有二分函数）

#include <algorithm>

int binary_search(List &list, int aim)
{
    int index = std::lower_bound(list.items, list.items + list.len, aim) - list.items;
    if(list.items[index] == aim) return index;
    else return -1;
}

二分查找判定树

二分查找的过程可以用树来表示，这个树称为判定树。

例如：

假设我们在有序顺序表 1 3 5 7 9 11 13 15 中查找元素，那么它的判定树是这样的

这里有个空结点是因为 markdown 画不出来二叉树的形状，因此这里用个空站位，实际上是没有这个结点的

通过判定树，我们可以直观地了解到，二分查找的比较次数与判定树的高度 h 有关。

由于二分查找的判定树是一棵接近满二叉树的平衡二叉树。结点个数为 n 的满二叉树的树高为$lo{g}_2(n+1)$。所以折半查找的时间复杂度近似为$O(lo{g}_{2}n)$。

分块查找（索引顺序查找）

分块查找结合了顺序查找和二分查找。它的核心是划分区间、添加索引。

当然，如果分区和添加索引是在查找开始时进行的，那么时间开销巨大，因此，分块查找实际上是对一种类似于跳表的数据结构进行的查找。

分块查找要求：

• 索引的值为每个块中的最大元素，索引指向块中的第一个元素。
• 索引的值必须是有序的，块内元素的值可以是无序的。

分块查找的过程分为两部：

1. 使用顺序查找或二分查找在索引表中查找记录所在的块。
2. 在块内进行顺序查找、

例如：现在有待查找序列 $24,21,6,11,8,22,32,31,54,72,61,78,88,83$

我们拟建立分块：

区间	块内元素	索引的值	索引
[1,6]	24, 21, 6, 11, 8, 22	24	1
[7, 9]	32, 31, 54	54	7
[10, 12]	72, 61, 78	78	10
[13, 14]	88, 83	88	13

在使用分块查找的时候先在索引列表里找到符合条件的区间，再到对应的区间里去找有没有符合条件的值。

假设我们要找32这个元素，那么从索引里找，发现32在 (24, 54]这个区间内。

所以，按照索引，从第7号元素开始执行顺序查找，第7号元素就是32，找到了返回下标。

---

在现实中，直接使用分块查找算法的情况并不多。但是分块的思想使用得非常多。例如大数据处理的时候，我们常常会将数据按照时间分块来提高处理速度。

最理想的分块情况

将长度为n的查找表均分为b块，每块有s个记录。设分块查询查找索引的平均查找长度为$L_i$，块内查找的平均查找长度为$L_s$。

在等概率的情况下，若在块内和块间均采用顺序查找，则平均查找长度

$ASL=L_i+L_s=(b+1)/2+(s+1)/2=(s^2+2s+n)/2s=(s+n/s+2)/2$

由均值不等式可知，在$s=\sqrt{n}$时，$(s+n/s+2)/2$ 最小。

所以，理想状况下，每个分块内的元素个数应为$s=\sqrt{n}$。

全篇结束，感谢阅读！