《数据结构与算法》（十六）- “查找”详解

原文地址：https://program-park.github.io/2021/11/15/algorithm_16/

前言

部分内容摘自程杰的《大话数据结构》

---

1. 查找概论

  只要打开电脑，就会涉及到查找技术。如炒股软件中查股票信息、硬盘文件中找照片、在光盘中搜DVD，甚至玩游戏时在内存中查找攻击力、魅力值等数据修改用来作弊等，都要涉及到查找。当然，在互联网上查找信息就更加是家常便饭。所有这些需要被查的数据所在的集合，我们给它一个统称叫查找表。
  查找表（Search Table）是由同一类型的数据元素（或记录）构成的集合。例如下图就是一个查找表。
  关键字（Key）是数据元素中某个数据项的值，又称为键值，用它可以标识一个数据元素。也可以标识一个记录的某个数据项（字段），我们称为关键码，如下图中①和②所示。
  若此关键字可以唯一地标识一个记录，则称此关键字为主关键字（Primary Key）。注意这也就意味着，对不同的记录，其主关键字均不相同。主关键字所在的数据项称为主关键码，如下图中③和④所示。
  那么对于那些可以识别多个数据元素（或记录）的关键字，我们称为次关键字（Secondary Key），如下图中⑤所示。次关键字也可以理解为是不以唯标识一个数据元素（或记录）的关键字，它对应的数据项就是次关键码。

查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。

  若表中存在这样的一个记录，则称查找是成功的，此时查找的结果给出整个记录的信息，或指示该记录在查找表中的位置。比如上图所示，如果我们查找主关键码 “代码” 的主关键字为 “sh601398” 的记录时，就可以得到第 2 条唯一记录。如果我们查找次关键码 “涨跌额” 为 “-0.11” 的记录时，就可以得到两条记录。
  若表中不存在关键字等于给定值的记录，则称查找不成功，此时查找的结果可给出一个 “空" 记录或 “空” 指针。
  查找表按照操作方式来分有两大种：静态查找表和动态查找表。
  静态查找表（Static Search Table）：只作查找操作的查找表。它的主要操作有：
    (1) 查询某个 “特定的” 数据元素是否在查找表中。
    (2) 检索某个 “特定的” 数据元素和各种属性。
  按照我们大多数人的理解，查找，当然是在已经有的数据中找到我们需要的。静态查找就是在干这样的事情，不过，现实中还有存在这样的应用：查找的目的不仅仅只是查找。
  比如网络时代的新名词，如反应年轻人生活的 “蜗居”、 “蚁族”、“孩奴”、 “啃老” 等，以及 “X客” 系列如博客、播客、闪客、黑客、威客等，  如果需要将它们收录到汉语词典中，显然收录时就需要查找它们是否存在，以及找到如果不存在时应该收录的位置。再比如，如果你需要对某网站上亿的注册用户进行清理工作，注销一些非法用户，你就需查找到它们后进行删除，删除后其实整个查找表也会发生变化。对于这样的应用，我们就引入了动态查找表。
  动态查找表（Dynamic Search Table）：在查找过程中同时插入查找表中不存在的数据元素，或者从查找表中删除已经存在的某个数据元素。显然动态查找表的操作就是两个：
    (1) 查找时插入数据元素。
    (2) 查找时删除数据元素。
  为了提高查找的效率，我们需要专门为查找操作设置数据结构，这种面向查找操作的数据结构称为查找结构。
  从逻辑上来说，查找所基于的数据结构是集合，集合中的记录之间没有本质关系。可是要想获得较高的查找性能，我们就不能不改变数据元素之间的关系，在存储时可以将查找集合组织成表、树等结构。
  例如，对于静态查找表来说，我们不妨应用线性表结构来组织数据，这样可以使用顺序查找算法，如果再对主关键字排序，则可以应用折半查找等技术进行高效的查找。
  如果是需要动态查找，则会复杂一些，可以考虑二叉排序树的查找技术。
  另外，还可以用散列表结构来解决一些查找问题， 这些技术都将在后面的讲解中说明。

2. 顺序表查找

  试想一下，要在散落的一大堆书中找到你需要的那本有多么麻烦。碰到这种情况的人大都会考虑做一件事，那就是把这些书排列整齐，比如竖起来放置在书架上，这样根据书名，就很容易查找到需要的图书。
  散落的图书可以理解为一个集合， 而将它们排列整齐，就如同是将此集合构造成一个线性表。我们要针对这一线性表进行查找操作，因此它就是静态查找表。
  此时图书尽管已经排列整齐，但还没有分类，因此我们要找书只能从头到尾或从尾到头一本一本查看，直到找到或全部查找完为止。这就是我们现在要讲的顺序查找。
  顺序查找（Sequential Search）又叫线性查找，是最基本的查找技术，它的查找过程是：从表中第一个（或最后一个）记录开始，逐个进行记录的关键字和给定值比较，若某个记录的关键字和给定值相等，则查找成功，找到所查的记录;如果直到最后一个（或第一个）记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找不成功。

2.1 顺序表查找算法

  顺序查找的算法实现如下：

/* 顺序查找，a为数组，n为要查找的数组个数，key 为要查找的关键字 */
int Sequential_Search(int *a,int n,int key)
{
	int i;
	for (i=1;i<-n;i++)
	{
		if (a[i]==key)
			return i;
	}
	return 0;
}

  这段代码非常简单，就是在数组a（注意元素值从下标 1 开始）中查看有没有关键字（key），当你需要查找复杂表结构的记录时，只需要把数组a与关键字key定义成你需要的表结构和数据类型即可。

2.2 顺序表找优化

  到这里并非足够完美，因为每次循环时都需要对i是否越界，即是否小于等于n作判断。事实上，还可以有更好一点的办法，设置一个哨兵，可以解决不需要每次让i与n作比较。看下面的改进后的顺序查找算法代码。

/* 有哨兵顺序查找 */
int Sequential_Search2(int *a,int n,int key)
{
	int i;
	a[0]=key;	/* 设置a[0]为关键字值，我们称之为“哨兵” */
	i=n;		/* 循环从数组尾部开始 */
	while(a[i]!=key)
	{
		i--;
	}
	return i;	/* 返回0则说明查找失败 */
}

  此时代码是从尾部开始查找，由于a[0]=key，也就是说，如果在a[i]中有key则返回i值，查找成功。否则一定在最终的a[0]处等于key，此时返回的是 0，即说明a[1]~a[n]中没有关键字key，查找失败。
  这种在查找方向的尽头放置 “哨兵” 免去了在查找过程中每一次比较后都要判断查找位置是否越界的小技巧，看似与原先差别不大，但在总数据较多时，效率提高很大，是非常好的编码技巧。当然，“哨兵” 也不一定就一定要在数组开始， 也可以在末端。
  对于这种顺序查找算法来说，查找成功最好的情况就是在第一个位置就找到了 ，算法时间复杂度为 $O(1)$，最坏的情况是在最后一位置才找到， 需要n次比较，时间复杂度为 $O(n)$，当查找不成功时，需要n+1次比较，时间复杂度为 $O(n)$。我们之前推导过，关键字在任何一位置的概率是相同的，所以平均查找次数为(n+1)/2，所以最终时间复杂度还是 $O(n)$。
  很显然，顺序查找技术是有很大缺点的，当n很大时，查找效率极为低下，不过优点也是有的，这个算法非常简单，对静态查找表的记录没有任何要求，在一些小型数据的查找时，是可以适用的。
  另外，也正由于查找概率的不同，我们完全可以将容易查找到的记录放在前面，而不常用的记录放置在后面，效率就可以有大幅提高。

3. 有序表查找

  我们如果仅仅是把书整理在书架上，要找到一本书还是比较困难的，也就是刚才讲的需要逐个顺序查找。但如果我们在整理书架时，将图书按照书名的拼音排序放置，那么要找到某一本书就相对容易了。说白了，就是对图书做了有序排列，一个线性表有序时，对于查找总是很有帮助的。

3.1 折半查找

  我们在讲树结构的二叉树定义时，曾经提到过一个小游戏，我在纸上已经写好了一个 100 以内的正整数数字请你猜，问几次可以猜出来，当时已经介绍了如何最快猜出这个数字。我们把这种每次取中间记录查找的方法叫做折半查找，如下图所示。

  折半查找（Binary Search）技术，又称为二分查找。它的前提是线性表中的记录必须是关键码有序（通常从小到大有序），线性表必须采用顺序存储。折半查找的基本思想是：在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上述过程，直到查找成功，或所有查找区域无记录，查找失败为止。
  假设我们现在有这样一个有序表数组 {0,1,16,24,35,47,59,62,73,88,99}， 除 0 下标外共 10 个数字。对它进行查找是否存在 62 这个数。我们来看折半查找的算法是如何工作的。

/* 折半查找 */
int Binary_Search(int *a,int n,int key)
{
	int low, high, mid;
	low=1;		/* 定义最低下标为记录首位 */
	high=n;		/* 定义最高下标为记录末位 */
	while(low<=high)
	{
		mid=(low+high)/2;	/* 折半 */
		if (key<a[mid])		/* 若查找值比中值小 */
			high=mid-1;		/* 最高下标调整到中位下标小一位 */
		else if (key>a[mid])	/* 若查找值比中值大 */
			low=mid+1;		/* 最低下标调整到中位下标大一位 */
		else
			return mid;		/* 若相等则说明mid即为查找到的位置 */
	}
	return 0;
}

1. 程序开始运行，参数a={0,1,16,24,35,47,59,62,73,8899}，n=10，key=62，第 3~5 行，此时low=1，high=10，如下图所示。
   
2. 第 6~15 行循环，进行查找。
3. 第 8 行，mid计算得 5，由于a[5]=47<key，所以执行了第 12 行，low=5+1=6，如下图所示。
   
4. 再次循环，mid=[6+10]/2=8，此时a[8]=73>key，所以执行第 10 行，high=8-1=7，如下图所示。
   
5. 再次循环，mid=(6+7)/2=6，此时a[6]=59<key，所以执行 12 行，low=6+1=7，如下图所示。
   
6. 再次循环，mid=(7+7)/2=7，此时a[7]=62=key，查找成功，返回 7。

  该算法还是比较容易理解的，同时我们也能感觉到它的效率非常高。但到底高多少？关键在于此算法的时间复杂度分析。
  首先，我们将这个数组的查找过程绘制成一棵二叉树， 如下图所示，从图上就可以理解，如果查找的关键字不是中间记录 47 的话，折半查找等于是把静态有序查找表分成了两棵子树，即查找结果只需要找其中的一半数据记录即可， 等于工作量少了一半，然后继续折半查找，效率当然是非常高了。

  我们之前讲的二叉树的性质 4，有过对 “具有n个结点的完全二叉树的深度为 [log${}_2$n]+1” 性质的推导过程。在这里尽管折半查找判定二叉树并不是完全二叉树，但同样相同的推导可以得出，最坏情况是查找到关键字或查找失败的次数为 [log${}_2$n]+1。
  有人还在问最好的情况？那还用说吗，当然是 1 次了。
  因此最终我们折半算法的时间复杂度为 $O(logn)$，它显然远远好于顺序查找的 $O(n)$ 时间复杂度了。
  不过由于折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，这样的算法已经比较好了。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。

3.2 插值查找

  现在我们的新问题是，为什么一定要折半，而不是折四分之一或者折更多呢？
  打个比方，在英文词典里查 “apple”，你下意识里翻开词典是翻前面的书页还是后面的书页呢？如果再让你查 “zoo”，你又怎么查？很显然，这里你绝对不会是从中间开始查起，而是有一定目的的往前或往后翻。
  同样的，比如要在取值范围 0~1000 之间 100 个元素从小到大均匀分布的数组中查找 5，我们自然会考虑从数组下标较小的开始查找。
  看来，我们的折半查找，还是有改进空间的。
  折半查找代码的第 8 句，我们略微等式变换后得到：
$$mid=\frac{low+high}{2}=low+\frac{1}{2}(high-low)$$  也就是mid等于最低下标low加上最高下标high与low的差的一半。算法科学家们考虑的就是将这个 1/2 进行改进，改进为下面的计算方案：
$$mid=low+\frac{key-a[low]}{a[high]-a[low]}(high-low)$$
  将 1/2 改成了 $\frac{key-a[low]}{a[high]-a[low]}$ 有什么道理呢？假设a[11]={0,1,16,24,35,47,59,62,73,88,99}，low=1，high=10，则a[low]=1，a[high]=99，如果我们要找的是key=16时，按原来折半的做法，我们需要四次才可以得到结果，但如果用新办法， $\frac{key-a[low]}{a[high]-a[low]}$=(16-1) / (99-1)≈0.153，即mid≈1+0.153×(10-1) =2.377取整得到mid=2，我们只需要二次就查找到结果了，显然大大提高了查找的效率。
  换句话说，我们只需要在折半查找算法的代码中更改一下第 8 行代码如下：

mid=lowt + (high-low) * (key-a[low]) / (a[high]-a[low]);	/* 插值 */

  就得到了另一种有序表查找算法——插值查找法。插值查找（Interpolation Search）是根据要在找的关键字key与查找表中最大最小记录的关键字比较后的查找方法，其核心就在于插值的计算公式$\frac{key-a[low]}{a[high]-a[low]}$。应该说，从时间复杂度来看，它也是$O(logn)$，但对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好得多。反之，数组中如果分布类似 {0,1,2,2000,2001,…,999998, 999999} 这种极端不均匀的数据，用插值查找未必是很合适的选择。

3.3 斐波那契查找

  还有没有其他办法？我们折半查找是从中间分，也就是说，每一次查找总是一 分为二，无论数据偏大还是偏小，很多时候这都未必就是最合理的做法。除了插值查找，我们再介绍一种有序查找，斐波那契查找（Fibonaci Search），它是利用了黄金分割原理来实现的。
  为了能够介绍清楚这个查找算法，我们先需要有一个斐波那契数列的数组，如下图所示。

  下面我们根据代码来看程序是如何运行的。

/* 斐波那契查找 */
int Fibonacci_Search(int *a,int n,int key)
{
	int low,high,mid,i,k;
	low=1;	/* 定义最低下标为记录首位 */
	high-n;	/* 定义最高下标为记录末位 */
	k=0;
	while(n>F[k]-1)	/* 计算n位于斐波那契数列的位置 */
		k++;
	for (i-n;i<F[k)-1;i++)	/* 将不满的数值补全 */
		a[i]=a[n];
	while(low<-high)
	{
		mid=low+F[k-1]-1;	/* 计算当前分隔的下标 */
		if (key<a(mid])		/* 若查找记录小于当前分隔记录 */
		{
			high=mid-1;		/* 最高下标调整到分隔下标mid-1处 */
			k=k-1:			/* 斐波那契数列下标减一位 */
		}
		else if (key>a[mid])	/* 若查找记录大于当前分隔记录 */
		{
			low=mid+1;		/* 最低下标调整到分隔下标mid+1处 */
			k=k-2;			/* 斐波那契数列下标减两位 */
		}
		else
		{
			if (mid<=n)
				return mid;	/* 若相等则说明mid即为查找到的位置 */
			else
				return n;	/* 若mid>n说明是补全数值，返回n */
		}
	}
	return 0;
}

1. 程序开始运行，参数a={0,1,16,24,35,47,59,62,73,88,99}，n=10，要查找的关键字key=59。注意此时我们已经有了事先计算好的全局变量数组F的具体数据，它是斐波那契数列，F={0,1,1,2,3,5,8,13,21,···}。
   
2. 第 6~8 行是计算当前的n处于斐波那契数列的位置。现在n=10，F[6]<n<F[7]，所以计算得出k=7。
3. 第 9~10 行，由于k=7，计算时是以F[7]=13为基础，而a中最大的仅是a[10]，后面的a[11]，a[12]均未赋值， 这不能构成有序数列，因此将它们都赋值为最大的数组值，所以此时a[11]=a[12]=a[10]=99（此段代码作用后面还有解释）。
4. 第 11~31 行查找正式开始。
5. 第 13 行，mid=1+F[7-1]-1=8，也就是说，我们第一个要对比的数值是从下标为 8 开始的。
6. 由于此时key=59而a[8]=73，因此执行第 16~17 行，得到high=7，k=6。
   
7. 再次循环，mid=1+F[6-1]-1=5。 此时a[5]=47<key，因此执行第 21~22 行，得到low=6，k=6- 2=4。注意此时k下调 2 个单位。
   
8. 再次循环，mid=6+F[4-1]-1=7。此时a[7]=62>key，因此执行第 16~17 行，得到high=6，k=4-1=3。
   
9. 再次循环，mid=6+F[3-1]-1=6。此时a[6]=59=key，因此执行第 26~27 行，得到返回值为 6。程序运行结束。

  如果key=99，此时查找循环第一次时，mid=8与上例是相同的，第二次循环时，mid=11，如果a[11]没有值就会使得与key的比较失败，为了避免这样的情况出现，第 9~10 行的代码就起到这样的作用。
  斐波那契查找算法的核心在于：
   ①当key=a[mid]时，查找就成功；
   ②当key<a[mid]时，新范围是第low个到第mid-1个，此时范围个数为F[k-1]-1个；
   ③当key>a[mid]时，新范围是第m+1个到第high个，此时范围个数为F[k-2]-1个。

  也就是说，如果要查找的记录在右侧，则左侧的数据都不用再判断了，不断反复进行下去，对处于当中的大部分数据，其工作效率要高一些。所以尽管斐波那契查找的时间复杂也为 $O(logn)$，但就平均性能来说，斐波那契查找要优于折半查找。可惜如果是最坏情况，比如这里key=1，那么始终都处于左侧长半区在查找，则查找效率要低于折半查找。
  还有比较关键的一点，折半查找是进行加法与除法运算(mid=(low+high)/2)，插值查找进行复杂的四则运算(mid=low+(high-low)*(key-a[low])/(a[high]-a[low])，而斐波那契查找只是最简单加减法运算(mid=low+F[k-1]-1)，在海量数据的查找过程中，这种细微的差别可能会影响最终的查找效率。
  应该说，三种有序表的查找本质上是分隔点的选择不同，各有优劣，实际开发时可根据数据的特点综合考虑再做出选择。

4. 线性索引查找

  我们前面讲的几种比较高效的查找方法都是基于有序的基础之上的，但事实上，很多数据集可能增长非常快，例如，某些微博网站或大型论坛的帖子和回复总数每天都是成百万上千万条，或者一些服务器的日志信息记录也可能是海量数据，要保证记录全部是按照当中的某个关键字有序，其时间代价是非常高昂的，所以这种数据通常都是按先后顺序存储。
  那么对于这样的查找表，我们如何能够快速查找到需要的数据呢？办法就是一索引。
  数据结构的最终目的是提高数据的处理速度，索引是为了加快查找速度而设计的一种数据结构。 索引就是把一个关键字与它对应的记录相关联的过程，一个索引由若千个索引项构成，每个索引项至少应包含关键字和其对应的记录在存储器中的位置等信息。索引技术是组织大型数据库以及磁盘文件的一种重要技术。
  索引按照结构可以分为线性索引、树形索引和多级索引。我们这里就只介绍线性索引技术。所谓线性索引就是将索引项集合组织为线性结构，也称为索引表。我们重点介绍三种线性索引：稠密索引、分块索引和倒排索引。

4.1 稠密索引

  家里老人年纪大了，记忆力不好，经常在家里找不到东西，于是她想到了一个办法。她用一小本子记录了家里所有小东西放置的位置，比如户口本放在右手床头柜下面抽屉中，针线放在电视柜中间的抽屉中······，总之，她把这些小物品的放置位置都记录在了小本子上，并且每隔一段时间还按照本子整理一遍家中的物品，用完都放回原处，这样她就几乎再没有找不到东西。
  从这件事就可以看出，家中的物品尽管是无序的，但是如果有一个小本子记录，寻找起来也是非常容易，而这小本子就是索引。
  稠密索引是指在线性索引中，将数据集中的每个记录对应一个索引项，如下图所示。

  刚才的小例子和稠密素引还是略有不同，家里的东西毕竟少，小本子再多也就几十页，全部翻看完就几分钟时间，而稠密索引要应对的可能是成千，上万的数据，因此对于稠密索引这个索引表来说，索引项一定是按照关键码有序的排列。
  索引项有序也就意味着，我们要查找关键字时，可以用到折半、插值、斐波那契等有序查找算法，大大提高了效率。比如上图中，我要查找关键字是 18 的记录，如果直接从右侧的数据表中查找，那只能顺序查找，需要查找 6 次才可以查到结果。而如果是从左侧的索引表中查找，只需两次折半查找就可以得到 18 对应的指针，最终查找到结果。
  这显然是稠密索引优点，但是如果数据集非常大，比如上亿，那也就意味着索引也得同样的数据集长度规模，对于内存有限的计算机来说，可能就需要反复去访问磁盘，查找性能反而大大下降了。

4.2 分块索引

  回想一下图书馆是如何藏书的。显然它不会是顺序摆放后，给我们一个稠密索引表去查，然后再找到书给你。图书馆的图书分类摆放是一门非常完整的科学体系，而它最重要的一个特点就是分块。
  稠密索引因为索引项与数据集的记录个数相同，所以空间代价很大。为了减少索引项的个数，我们可以对数据集进行分块，使其分块有序，然后再对每一块建立一个索引项，从而减少索引项的个数。
  分块有序，是把数据集的记录分成了若千块，并且这些块需要满足两个条件：

• 块内无序，即每一块内的记录不要求有序。当然，你如果能够让块内有序对查找来说更理想，不过这就要付出大量时间和空间的代价，因此通常我们不要求块内有序。
• 块间有序，例如，要求第二块所有记录的关键字均要大于第一块中所有 记录的关键字，第三块的所有记录的关键字均要大于第二块的所有记录关键字······因为只有决间有序，才有可能在查找时带来效率。

  对于分块有序的数据集，将每块对应一个索引项，这种索引方法叫做分块索引。  如下图所示，我们定义的分块索引的索引项结构分三个数据项：

• 最大关键码， 它存储每一块中的最大关键字，这样的好处就是可以使得在它之后的下一块中的最小关键字也能比这一块最大的关键字要大；
• 存储了块中的记录个数，以便于循环时使用；
• 用于指向块首数据元素的指针，便于开始对这一块中记录进行遍历。

  应该说，分块索引的思想是很容易理解的，我们通常在整理书架时，都会考虑不同的层板放置不同类别的图书。例如，我家里就是最上层放不太常翻阅的小说书，中间层放经常用到的如菜谱、字典等生活和工具用书，最下层放大开本比较重的计算机书。这就是分块的概念，并且让它们块间有序了。至于上层中《红楼梦》是应该放在《三国演义》的左边还是右边，并不是很重要。毕竞要找小说《三国演义》，只需要对这一层的图书用眼睛扫过一遍就能很容易查找到。
  我们再来分析一下分块索引的平均查找长度。设n个记录的数据集被平均分成m块，每个块中有t条记录，显然n=m×t，或者说m=n/t。再假设 L${}_b$ 为查找索引表的m+1平均查找长度，因最好与最差的等概率原则，所以 L${}_b$ 的平均长度为 $\frac{m+1}{2}$。L${}_w$ 为块中查找记录的平均查找长度，同理可知它的平均查找长度为 $\frac{t+1}{2}$。
  这样分块索引查找的平均查找长度为：
$$AS{L}_W=L_b+L_w=\frac{m+1}{2}+\frac{t+1}{2}=\frac{1}{2}(m+t)+1=\frac{1}{2}(\frac{n}{t}+1)$$
  注意上面这个式子的推导是为了让整个分块索引查找长度依赖n和t两个变量。从这里了我们也就得到，平均长度不仅仅取决于数据集的总记录数n，还和每一个块的记录个数t相关。最佳的情况就是分的块数m与块中的记录数t相同，此时意味着 n=m×t=t²，即 $AS{L}_w=\frac{1}{2}(\frac{n}{t}+t)+1=t+1=\sqrt{n}+1$
  可见，分块索引的效率比之顺序查找的 $O(n)$ 是高了 不少，不过显然它与折半查找的 $O(logn)$ 相比还有不小的差距。因此在确定所在块的过程中，由于块间有序，所以可以应用折半、插值等手段来提高效率。
  总的来说，分块索引在兼顾了对细分块不需要有序的情况下，大大增加了整体查找的速度，所以普遍被用于数据库表查找等技术的应用当中。

4.3 倒排索引

  我不知道大家有没有对搜索引擎好奇过，无论你查找什么样的信息，它都可以在极短的时间内给你一些结果，如下图所示。是什么算法技术达到这样的高效查找呢？

  我们在这里介绍最简单的，也算是最基础的搜索技术——倒排索引。
  我们来看样例，现在有两篇极短的英文 “文章" ——其实只能算是句子， 我们暂认为它是文章，编号分别是 1 和 2。

1. Books and friends should be few but good. (读书如交友，应求少而精。)
2. A good book is a good friend (好书如挚友。)

  假设我们忽略掉如 “books”，“friends” 中的复数 “s” 以及如 “A” 这样的大小写多篇文章所有单词建立倒排索引，那每个单词都将对应相当多的文章编号，维护比较困难，插入和删除操作都需要作相应的处理。
  当然，现实中的搜索技术非常复杂，比如我们不仅要知道某篇文章有要搜索的关键字，还想知道这个关键字在文章中的哪些地方出现，这就需要我们对记录号表做一些改良。再比如，文章编号上亿，如果都用长数字也没必要，可以进行压缩，比如三篇文章的编号是 “112.115,119"，我们可以记录成 “112, +3, +4"，即只记录差值，这样每个关键字就只占用一两个字节。 甚至关键字也可以压缩，比如前一条记录的关键字是 “and” 而后一条是“android”，那么后面这个可以改成 “< 3,roid >"，这样也可以起到压缩数据的作用。再比如搜索时，尽管告诉你有几千几万条查找到的记录，但其实真正显示给你看的，就只是当中的前 10 或者 20 条左右数据，只有在点击下一页时才会获得后面的部分索引记录，这也可以大大提高了整体搜索的效率。
  当然，如果文章是中文就更加复杂。比如文章中出现 “中国人”，它本身是关键字，那么 “中国”、“国人” 也都可能是要查找的关键字。如果想彻底弄明白可以自己进行深入学习，这里只做抛砖引玉的作用。

5. 总结

  这一篇全都是围绕一个主题 “查找” 来写的。
  首先我们要弄清楚查找表、记录、关键字、主关键字、静态查找表、动态查找表等这些概念。
  然后，对于顺序表查找来说，尽管很土（简单），但它却是后面很多查找的基础，注意设置 “哨兵” 的技巧，可以使得本已经很难提升的简单算法里还是提高了性能。
  有序查找，着重讲了折半查找的思想，它在性能上比原来的顺序查找有了质的飞跃，由 $O(n)$ 变成了 $O(logn)$。 之后我们又讲解了另外两种优秀的有序查找：插值查找和斐波那契查找，三者各有优缺点。
  线性索引查找，讲了稠密索引、分块索引和倒排索引。索引技术被广泛的用于文件检索、数据库和搜索引擎等技术领城，是进一步学习这些技术的基础。
  下一篇讲二叉排序树，这是动态查找中最重要的数据结构。