数据结构，查找专题，顺序查找、折半查找详解及C++详细实现

顺序查找

顺序查找又称线性查找，它对顺序表和链表都是适用的。对于顺序表，可通过数组下标递增来顺序扫描每个元素；对于链表，可通过指针 $\mathrm{next}$ 来依次扫描每个元素。顺序查找通常分为对一般的无序线性表的顺序查找和对按关键字有序的线性表的顺序查找。下面分别进行讨论。

1.一般线性表的顺序查找

作为一种最直观的查找方法，其基本思想是从线性表的一端开始，逐个检查关键字是否满足给定的条件。
若查找到某个元素的关键字满足给定条件，则查找成功，返回该元素在线性表中的位置；
若已经查找到表的另一端，但还没有查找到符合给定条件的元素，则返回查找失败的信息。
下面给岀其算法，主要是为了说明其中引入的“哨兵”的作用。

#include <iostream>

using namespace std;

template<typename T>
struct SSTable {
    T *element;
    int TableLen;
};

template<typename T>
int Seq_Search(SSTable<T> ST, T key) {
    ST.element[0] = key;  //哨兵

    //从后往前找
    int i = ST.TableLen;
    while (ST.element[i] != key)
        i--;

    return i; //若表中不存在关键字为key的元素，将查找到i为0
}

int main() {
    SSTable<int> ST;
    ST.TableLen = 10;
    ST.element = new int[ST.TableLen + 1];
    for (int i = 1; i <= ST.TableLen; i++)
        ST.element[i] = i;

    cout << Seq_Search(ST, 11) << endl;
    cout << Seq_Search(ST, 8) << endl;
    return 0;
}

运行结果：

0
8

在上述算法中，将ST.element[0]称为“哨兵”。引入它的目的是使得Seq_Search内的循环不必判断数组是否会越界，因为满足i==0时，循环一定会跳出。需要说明的是，在程序中引入“哨兵”并不是这个算法独有的。引入“哨兵”可以避免很多不必要的判断语句，从而提高程序效率。

对于有 $\mathrm{n}$ 个元素的表，给定值key与表中第 $\mathrm{i}$ 个元素相等，即定位第 $\mathrm{i}$ 个元素时，需进行 $\mathrm{n}-\mathrm{i}+1$ 次关键字的比较，即 ${\mathrm{C}}_{\mathrm{i}}=\mathrm{n}-\mathrm{i}+1$ 。查找成功时，顺序查找的平均长度为：
$$\mathrm{AS}{\mathrm{L}}_{\mathrm{成功}}=\sum _{i=1}^n{P}_i(n-i+1)$$
当每个元素的查找概率相等，即 ${\mathrm{P}}_{\mathrm{i}}=1/n$ 时，有：
$$\mathrm{AS}{\mathrm{L}}_{\mathrm{成功}}=\sum _{i=1}^n{P}_i(n-i+1)=\frac{n+1}{2}$$
查找不成功时，与表中各关键字的比较次数显然是 $\mathrm{n}+1$ 次，从而顺序查找不成功的平均查找长度为 $\mathrm{AS}{\mathrm{L}}_{\mathrm{不成功}}=\mathrm{n}+1$ 。

通常，查找表中记录的查找概率并不相等。若能预先得知每个记录的查找概率，则应先对记录的查找概率进行排序，使表中记录按查找概率由大至小重新排列。

综上所述，顺序查找的缺点是当 $\mathrm{n}$ 较大时，平均查找长度较大，效率低；优点是对数据元素的存储没有要求，顺序存储或链式存储皆可。对表中记录的有序性也没有要求，无论记录是否按关键字有序，均可应用。同时还需注意，对线性的链表只能进行顺序查找。

2.有序表的顺序查找

若在查找之前就已经知道表是关键字有序的，则查找失败时可以不用再比较到表的另一端就能返回查找失败的信息，从而降低顺序查找失败的平均查找长度。

假设表 $\mathrm{L}$ 是按关键字从小到大排列的，查找的顺序是从前往后，待查找元素的关键字为key, 当查找到第 $\mathrm{i}$ 个元素时，发现第 $\mathrm{i}$ 个元素对应的关键字小于key，但第 $\mathrm{i}+1$ 个元素对应的关键字大于key，这时就可返回查找失败的信息，因为第 $\mathrm{i}$ 个元素之后的元素的关键字均大于key，所以表中不存在关键字为key的元素。

可以用下图所示的判定树来描述有序线性表的查找过程。树中的圆形结点表示有序线性表中存在的元素；树中的矩形结点称为失败结点(若有 $\mathrm{n}$ 个结点，则相应地有 $\mathrm{n}+1$ 个查找失败结点)，它描述的是那些不在表中的数据值的集合。若查找到失败结点，则说明查找不成功。

有序顺序表上的顺序查找判定树

在有序线性表的顺序查找中，查找成功的平均查找长度和一般线性表的顺序查找一样。查找失败时，查找指针一定走到了某个失败结点。这些失败结点是我们虚构的空结点，实际上是不存在的，所以到达失败结点时所查找的长度等于它上面的一个圆形结点的所在层数。查找不成功的平均查找长度在相等查找概率的情形下为
$$\mathrm{AS}{\mathrm{L}}_{\mathrm{不成功}}=\sum _{j=1}^n{q}_j(l_j-1)=\frac{1+2+\cdots +n+n}{n+1}=\frac{n}{2}+\frac{n}{n+1}$$
式中，$q_j$ 是到达第 $\mathrm{j}$ 个失败结点的概率，在相等查找概率的情形下，它为 $1/(\mathrm{n}+1)$；$l_i$是第 $\mathrm{j}$ 个失败结点所在的层数。

注意，有序线性表的顺序查找和后面的折半查找的思想是不一样的，且有序线性表的顺序查找中的线性表可以是链式存储结构。

折半查找

折半查找又称二分查找，它仅适用于有序的顺序表。

折半查找的基本思想：首先将给定值key与表中中间位置的元素比较，若相等，则查找成功，返回该元素的存储位置；若不等，则所需查找的元素只能在中间元素以外的前半部分或后半部分 (例如，在查找表升序排列时，若给定值key大于中间元素，则所查找的元素只可能在后半部分)。 然后在缩小的范围内继续进行同样的查找，如此重复，直到找到为止，或确定表中没有所需要查找的元素，则查找不成功，返回查找失败的信息。算法如下

#include <iostream>

using namespace std;

template<typename T>
struct SeqList {
    T *element;
    int TableLen;
};

template<typename T>
int Binary_Search(SeqList<T> L, T key) {
    int low = 0, high = L.TableLen - 1, mid;

    while (low <= high) {
        mid = (low + high) / 2;         //取中间位置

        if (L.element[mid] == key)
            return mid;                 //查找成功则返回所在位置
        else if (L.element[mid] > key)
            high = mid - 1;             //从前半部分继续查找
        else
            low = mid + 1;              //从后半部分继续查找
    }

    return -1;  //查找失败，返回-1
}

int main() {
    SeqList<int> seqList;
    seqList.TableLen = 10;
    seqList.element = new int[seqList.TableLen];
    for (int i = 0; i < seqList.TableLen; i++)
        seqList.element[i] = i;

    cout << Binary_Search(seqList, 11) << endl;
    cout << Binary_Search(seqList, 8) << endl;
    return 0;
}

输出结果：

-1
8

例如，已知11个元素的有序表{7, 10, 13, 16, 19, 29, 32, 33, 37, 41, 43}，指针low和high分别指向表的下界和上界，mid则指向表的中间位置 $\lfloor (\mathrm{low}+\mathrm{high})/2\rfloor$，以下说明查找11的过程：

第一次查找，将中间位置元素与key值比较。因为11<29，说明待查元素若存在，则必在范围[low,mid-1]内，令指针high指向位置mid-1, high=mid-1=5，重新求得mid = (1 + 5) / 2 = 3，第二次的查找范围为[1,5]

第二次查找，同样将中间位置元素与key值比较。因为11<13，说明待查元素若存在，则必在范围[low,mid-1]内，令指针high指向位置mid-1, high=mid-1=2 ，重新求得mid = (l + 2) / 2 = 1，第三次的查找范围为[1,2]

第三次查找，将中间位置元素与key值比较。因为11>7，说明待查元素若存在，则必在范围[mid+1,high]内。令low=mid+1=2, mid= (2+2)/2=2，第四次的查找范围为[2,2]。

第四次查找，此时子表只含有一个元素，且10!=11，故表中不存在待查元素。

折半查找的过程可用下图所示的二叉树来描述，称为判定树。树中每个圆形结点表示一个记录，结点中的值为该记录的关键字值；树中最下面的叶结点都是方形的，它表示查找不成功的情况。从判定树可以看出，查找成功时的查找长度为从根结点到目的结点的路径上的结点数，而查找不成功时的查找长度为从根结点到对应失败结点的父结点的路径上的结点数；每个结点值均大于其左子结点值，且均小于于其右子结点值。若有序序列有 $\mathrm{n}$ 个元素，则对应的判定树有 $\mathrm{n}$ 个圆形的非叶结点和 $\mathrm{n}+1$ 个方形的叶结点。显然，判定树是一棵平衡二叉树。

描述折半查找过程的判定树

由上述分析可知，用折半查找法查找到给定值的比较次数最多不会超过树的高度。在等概率查找时，查找成功的平均查找长度为
$$\mathrm{ASL}=\frac{1}{n}\sum _{i=1}^n{l}_i=\frac{1}{n}(1\times 1+2\times 2+\cdots +h\times 2^{h-1})=\frac{n+1}{n}{\log }_2(n+1)-1\approx {\log }_2(n+1)-1$$
式中，$h$ 是树的高度，并且元素个数为 $n$ 时树高 $h=\lceil {\log }_2(n+1)\rceil$。所以，折半查找的时间复杂度为 $O({\log }_{2}n)$，平均情况下比顺序查找的效率高。

因为折半查找需要方便地定位查找区域，所以它要求线性表必须具有随机存取的特性。因此，该查找法仅适合于顺序存储结构，不适合于链式存储结构，且要求元素按关键字有序排列。