查找（顺序表&有序表）

【1】查找概论

查找表是由同一类型是数据元素（或记录）构成的集合。

关键字是数据元素中某个数据项的值，又称为键值。

若此关键字可以唯一标识一个记录，则称此关键字为主关键字。

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

查找分为两类：静态查找表和动态查找表。

静态查找表：只作查找操作的查找表。主要操作：

（1）查询某个“特定的”数据元素是否在查找表中。

（2）检索某个“特定的”数据元素和各种属性。

动态查找表：在查找过程中同时插入查找表中不存在的数据元素，或者从查找表中删除已经已经存在的某个数据元素。 主要操作：

（1）查找时插入数据元素。

（2）查找时删除数据元素。

好吧！两者的区别： 静态查找表只负责查找任务，返回查找结果。

而动态查找表不仅仅负责查找，而且当它发现查找不存在时会在表中插入元素（那也就意味着第二次肯定可以查找成功）

【2】顺序表查找

顺序表查找又称为线性查找，是最基本的查找技术。 它的查找思路是：

逐个遍历记录，用记录的关键字和给定的值比较：

若相等，则查找成功，找到所查记录； 反之，则查找不成功。

顺序表查找算法代码如下：

对于这种查找算法，查找成功最好就是第一个位置找到，时间复杂度为O(1)。

最坏情况是最后一个位置才找到，需要n次比较，时间复杂度为O(n) 显然，n越大，效率越低下。

【3】有序表查找

所谓有序表，是指线性表的数据有序排列。

（1）折半查找

关于这个算法不做赘述，代码如下：

 #include <iostream>
 using namespace std;
 
 // 折半查找算法（二分查找）
 int Binary_Search(int* a,int n,int key)
 {
     int low = , high = n, mid = ;  // 初始化
     while (low <= high)    // 注意理解这里还有等于条件
     {
         mid = (low + high)/; // 折半
         if (key < a[mid])
             high = mid -;    // 最高小标调整到中位小一位
         else if (key > a[mid])
             low = mid + ;    // 最低下标调整到中位大一位
         else
             return mid;         // 相等说明即是
     }
     return ;
 }
 
 void  main ()
 {
     int a[] = {,,,,,,,,,,};
     int n = Binary_Search(a,, );
     if (n != )
         cout << "Yes:" << n << endl;
     else
         cout << "No:" << endl;
 }

折半查找算法的时间复杂度为O(logn)。

（2）插值查找

考虑一个问题：为什么是折半？而不是折四分之一或者更多呢？ 好吧，且看分解：

（3）斐波那契查找

斐波那契查找利用了黄金分割原理来实现。 如何利用斐波那契数列作为分割呢？

为了理清这个查找算法，首先需要一个斐波那契数列，如下图所示：

查找算法如下描述：

注意阅读以下详解之前，请先编译并运行第四部分的实例代码，结合代码再理解算法。

首先要明确一点：

如果一个有序表的元素个数为n，并且n正好是某个斐波那契数-1，即n == F[k]-1时，才能用斐波那契查找法。

1. 如果有序表的元素个数n不等于某个斐波那契数-1，即n != F[k]-1，如何处理呢？

　这时必须要将有序表的元素个数扩展到比n大的第一个斐波那契数-1的个数才符合算法的查找条件。

　通俗点讲，也就是为了使用斐波那契查找法，那么要求所查找顺序表的元素个数n必须满足n == F[k]-1这样的条件才可以。

　因为查找表为从小到大的顺序表，所以如果数据元素个数不满足要求，只有在表末用顺序表的最大值补满。

　代码中第9-10行的作用恰是如此。

2. 对于二分查找，分割点是从mid= (low+high)/2开始。

　而对于斐波那契查找，分割是从mid = low + F[k-1] - 1开始的。 为什么如此计算？

　用实例验证，比如本例中： 第一次进入查找循环时，数组元素个数准确说应该是12（包括随后补满的元素）

　而黄金分割点比例为0.618，那么12*0.618=7.416，此值对应12个元素应该为a[8]

　观察程序运行第一次mid=1+F[7-1]-1=8，正是此原理所体现。

　key=59，a[8]=73，显然key<a[8]，可知low=1，high=7，k=7-1=6

　注意此条件意思即为7个数据元素，正好满足F[6]-1=7的再次查找客观要求

　而同理，黄金分割点比例为0.618，那么7*0.618=4.326，此值对应7个元素应该为a[5]

　再看第二次进入循环mid=1+F[6-1]-1=5，正是此原理所体现。

　key=59，a[5]=47，显然key>a[5]，可知low=6，high=7，k=6-2=4

　注意此条件意思即为2个数据元素，正好满足F[4]-1=2的再次查找客观要求

　而同理黄金分割点比例为0.618，那么2*0.618=1.236，此值对应2个元素中的第二个即为a[7]

　key=59，a[7]=62，显然key<a[7]，可知low=6，high=6，k=4-1=3

　同理mid=6+F[3-1]-1=6。此时a[6]=59=key。 即查找成功。

3. 注意紧接着下面一句代码可以改写为：

　return  (mid <= n) ? mid : n;

　当然这样写也没有功能错误，但是细细琢磨还是有逻辑问题：

　mid == n时，返回为n; mid > n时返回也是n。

　那么到底n属于那种情况下的返回值呢？是否有违背if的本质！

　窃以为写成if(mid < n)会合理些。

　另外，许多资料对于这步判断描述如下：

　return  (mid <= high) ? mid : n;

　其实分析至此，我认为这种写法从代码逻辑而言更为合理。

4. 通过上面知道：数组a现在的元素个数为F[k]-1个，即数组长为F[k]-1。

　mid把数组分成了左右两部分，左边的长度为：F[k-1]-1

　那么右边的长度就为（数组长-左边的长度-1）： （F[k]-1）-（F[k-1]-1）= F[k]-F[k-1]-1 = F[k-2] - 1

5. 斐波那契查找的核心是：

a: 当key == a[mid]时，查找成功；

b: 当key<a[mid]时，新的查找范围是第low个到第mid-1个，此时范围个数为F[k-1] - 1个，

　即数组左边的长度，所以要在[low, F[k - 1] - 1]范围内查找；

c: 当key>a[mid]时，新的查找范围是第mid+1个到第high个，此时范围个数为F[k-2] - 1个，

　即数组右边的长度，所以要在[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】斐波那契算法代码实现

实例算法代码如下：

 #include <iostream>
 #include <assert.h>
 using namespace std;
 
 #define  MAXSIZE  11
 
 // 斐波那契非递归
 void Fibonacci(int *f)
 {
     f[] = ;
     f[] = ;
 
     for (int i = ; i < MAXSIZE; ++i)
     {
         f[i] = f[i-] + f[i-];
     }
 }
 // 斐波那契数列
 /*---------------------------------------------------------------------------------
   |  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  10  |  11  |  12  |
   ----------------------------------------------------------------------------------
   |     0  |  1  |  1  |  2  |  3  |  5  |  8  |  13 |  21 |  34 |  55  |  89  |  144 |
  -----------------------------------------------------------------------------------*/
 // 斐波那契数列查找
 int Fibonacci_Search(int *a, int n, int key)
 {
     int low = ;  // 定义最低下标为记录首位
     int high = n; // 定义最高下标为记录末位（一般输入的参数n必须是数组的个数减一）
 
     int F[MAXSIZE];
     Fibonacci(F); // 确定斐波那契数列
 
     int k = , mid = ;
     // 查找n在斐波那契数列中的位置，为什么是F[k]-1，而不是F[k]？
     while (n > F[k]-)
     {
         k++;
     }
     // 将不满的数值补全
     for (int i = n; i < F[k]-; ++i)
     {
         a[i] = a[high];
     }
     // 查找过程
     while (low <= high)
     {
         mid = low + F[k-] - ; // 为什么是当前分割的下标？
         if (key < a[mid])  // 查找记录小于当前分割记录
         {
             high = mid - ;
             k = k - ;     // 注意:思考这里为什么减一位？
         }
         else if (key > a[mid]) // 查找记录大于当前分割记录
         {
             low = mid + ;
             k = k - ;  // 注意:思考这里为什么减两位？
         }
         else
         {
             return (mid <= high) ? mid : n;  // 若相等则说明mid即为查找到的位置； 若mid > n 说明是补全数值，返回n
         }
     }
     return -;
 }
 void main()
 {
     int a[MAXSIZE] = {,,,,,,,,,,};
     int k = ;
     cout << "请输入要查找的数字:" << endl;
     cin >> k;
     int pos = Fibonacci_Search(a, MAXSIZE-, k);
     if (pos != -)
         cout << "在数组的第"<< pos+ <<"个位置找到元素:" << k;
     else
         cout << "未在数组中找到元素:" << k;
 }

若结合以上相关分析深入理解代码。

Good  Good  Study, Day   Day  Up.

顺序  选择  循环  总结