基础算法 — 有序表查找

折半查找（二分查找）

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

折半查找 (Binary Search) 技术，又称为二分查找。它的前提是线性表中的记录必须是关键码有序(通常从小到大有序) ，线性表必须采用顺序存储。折半查找的基本思想是：在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上述过程，直到查找成功，或所有查找区域元记录，查找失败为止。

假设我们现在有这样一个有序表数组{0，1，16，24，35，47，59，62，73，88，99} ，除 0 下标外共 10 个数字。对它进行查找是否存在 62 这个数。 我们来看折半查找的算法是如何工作的。代码实现如下：

public class BinarySearch {
  public static void main(String[] args) {
    int[] arry = {0, 1, 16, 24, 35, 47, 59, 62, 73, 88, 99};
    int key = 62;
    int n = binarySearch(key, arry);
    System.out.println("n:" + n);
  }

  public static int binarySearch(int key, int[] arry) {
    int low, high, mid;
    low = 1;// 定义起始查找位置
    high = arry.length;// 定义最后的查找位置
    while (low < high) {
      mid = (low + high) / 2;// 取中间位置的数字
      if (key < arry[mid]) {// 如果查找的值小于中间位置的数字
        high = mid - 1;// 将最大值变为中间位置的左边区域的值
      } else if (key > arry[mid]) {// 查找的值大于中间位置的数字
        low = mid + 1;// 将最小值变为中间位置右边区域的值
      } else {
        return mid;// 返回查到的位置
      }
    }
    return -1;
  }
}

结果如下：

该算法还是比较容易理解的，同时我们也能感觉到它的效率非常高。但到底高多 少?关键在于此算法的时阅复杂度分析。

首先，我们将这个数组的查找过程绘制成一棵二叉树，如下图所示，从图上就可以理解，如果查找的关键字不是中间记录 47 的话， 折半查找等于是把静态有序查找表分成了两棵子树，即查找结果只需要找其中的一半数据记录即可，等于工作量少了一半，然后继续折半查找，效率当然是非常高了。

我们之前讲的二叉树的性质 4，有过对 a具有 n 个结点的完全二叉树的深度为 [ log2^n ] + 1 性质的推导过程。 在这里尽管折半查找判定二叉树并不是完全二叉树，但同样相同的推导可以得出，最坏情况是查找到关键字或查找失败的次数为 [ log2^n ] + 1 。

有人问最好的情况? 当然是 1 次了。

因此最终我们折半算法的时间复杂度为[ logn] ，它显然远远好于顺序查找的 0(n) 时间复杂度了。

不过由于折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，这样的算法已经比较好了。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用了。

插值查找

1、从折半查照中可以看出，折半查找的查找效率还是不错的。可是为什么要折半呢？为什么不是四分之一、八分之一呢？打个比方，在牛津词典里要查找“apple”这个单词，会首先翻开字典的中间部分，然后继续折半吗？肯定不会，对于查找单词“apple”，我们肯定是下意识的往字典的最前部分翻去，而查找单词“zero”则相反，我们会下意识的往字典的最后部分翻去。所以在折半查找法的基础上进行改造就出现了插值查找法，也叫做按比例查找。所以插值查找与折半查找唯一不同的是在于mid的计算方式上，它的计算方式为：

mid = low + (high - low) * (searchValue - data[low]) / (data[high] - data[low])

2、时间复杂度

插值查找的时间复杂度也是O(log2n)，但是对于数据集合较长，且关键字分布比较均匀的数据集合来说，插值查找的算法性能比折半查找要好，其它的则不适用。

斐波那契查找

还有没有其他办法?我们折半查找是从中间分，也就是说，每一次查找总是一分为二 ，无论数据偏大还是偏小，很多时候这都未必就是最合理的做法。我们再介绍一种有序查找，斐波那契查找 (Fibonacci Search)，它是利用了黄金分割原理来实现的。

相对于二分查找和差值查找，斐波那契查找的实现略显复杂。但是在明白它的主体思想之后，掌握起来也并不太难。

既然叫斐波那契查找，首先得弄明白什么是斐波那契数列。相信大家对这个著名的数列也并不陌生，无论是C语言的循环、递归，还是高数的数列，斐波那契数列都是一个重要的存在。而此处主要是用到了它的一条性质：前一个数除以相邻的后一个数，比值无限接近黄金分割。

就笔者而言，这种查找的精髓在于采用最接近查找长度的斐波那契数值来确定拆分点,初次接触的童鞋，请在读完下文后，自觉回过头来仔细体会这句话。举个例子来讲，现有长度为9的数组，要对它进行拆分，对应的斐波那契数列（长度先随便取，只要最大数大于9即可）{1，1，2，3，5，8，13，21，34}，不难发现，大于9且最接近9的斐波那契数值是f[6]=13，为了满足所谓的黄金分割，所以它的第一个拆分点应该就是f[6]的前一个值f[5]=8，即待查找数组array的第8个数，对应到下标就是array[7]，依次类推。

推演到一般情况，假设有待查找数组array[n]和斐波那契数组F[k],并且n满足n>=F[k]-1&&n < F[k+1]-1，则它的第一个拆分点middle=F[k]-1。

这里得注意，如果n刚好等于F[k]-1,待查找数组刚好拆成F[k-1]和F[k-2]两部分，那万事大吉你好我好；然而大多数情况并不能尽人意，n会小于F[k]-1,这时候可以拆成完整F[k-1]和残疾的F[k-2]两部分，那怎么办呢？

聪明的前辈们早已想好了解决办法，对了，就是补齐，用最大的数来填充F[k-2]的残缺部分，如果查找的位置落到补齐的部分，那就可以确定要找的那个数就是最后一个最大的了，如图所示：

话不多说，代码如下：

public class FbonacciSearch {

  public static void main(String[] args) {
    int[] array = {1, 5, 15, 22, 25, 31, 39, 42, 47, 49, 59, 68, 88, 88,
        88, 88, 88};
    System.out.println("result: " + fbSearch(array, 31));
  }

  public static int fbSearch(int[] array, int a) {
    if (array == null || array.length == 0) {
      return -1;
    } else {
      int length = array.length;
      int[] fb = makeFbArray(20);// 制造一个长度为20的斐波数列
      int k = 0;
      while (length > fb[k] - 1) {// 找出数组的长度在斐波数列（减1）中的位置，将决定如何拆分
        k++;
      }
      int[] temp = Arrays.copyOf(array, fb[k] - 1);// 构造一个长度为fb[k] - 1的新数列
      for (int i = length; i < temp.length; i++) {
        if (i >= length) {
          temp[i] = array[length - 1];
        }
      }
      int low = 0;
      int hight = array.length - 1;
      while (low <= hight) {
        int middle = low + fb[k - 1] - 1;
        if (temp[middle] > a) {
          hight = middle - 1;
          k = k - 1;
        } else if (temp[middle] < a) {
          low = middle + 1;
          k = k - 2;
        } else {
          if (middle <= hight) {
            return middle;// 若相等则说明mid即为查找到的位置
          } else {
            return hight;// middle的值已经大于hight,进入扩展数组的填充部分,即最后一个数就是要查找的数。
          }
        }
      }
      return -1;
    }
  }

  public static int[] makeFbArray(int length) {
    int[] array = null;
    if (length > 2) {
      array = new int[length];
      array[0] = 1;
      array[1] = 1;
      for (int i = 2; i < length; i++) {
        array[i] = array[i - 1] + array[i - 2];
      }
    }
    return array;
  }


  public static int recurse(int[] array, int[] fb, int a, int low, int hight,
      int k) {
    if (array == null || array.length == 0 || a < array[low]
        || a > array[hight] || low > hight) {
      return -1;
    }
    int middle = low + fb[k - 1] - 1;
    if (a < array[middle]) {
      return recurse(array, fb, a, low, middle - 1, k - 1);
    } else if (a > array[middle]) {
      return recurse(array, fb, a, middle + 1, hight, k - 2);
    } else {
      if (middle <= hight) {
        return middle;
      } else {
        return hight;
      }
    }
  }
}