面试算法: 隐藏在《编程珠玑》中二十年的bug及二分查找法的相关面试算法

在算法面试中，排序和查找几乎是无法避免的问题，此类问题及其变种被问到的概率高达百分之九十以上。计算机程序要解决的问题，绝大多数都涉及到对大量数据的排列和查找。由此，掌握扎实的排序和查找技巧对算法面试而言至关重要，当面试官出的题目里含有数组或是数据集合时，你的第一反应应当要想到要把其中的数据或数组进行排序然后查找。

从本节开始，我们聚焦查找技术。给定含有n条记录的集合，确定某条记录是否包含在其中唯一的办法就是一条一条的查看给定记录是否与要查找的记录相符合，这需要的时间复杂度是O(n)。如果记录是以某种规律组织起来的，那么查找的速度就可以加快。

在所有查找技术中，我们必须要掌握的是二分查找法，这也是面试中最常考到的问题。二分查找既是一种技术，同时更是一种思考模式，很多技术创新都基于二分查找的思考方法之上，例如对于经验老道的高手程序员而言，二分法是调试困难bug的利器。

二分查找法的基本思路是，给定一个排好序的数组，要确定该数组是否含有给定元素，可以先看中间元素是否等于给定元素，如果不等，那么根据数组的排序特性，我们可以确定，该数组要包含该元素的话，那么该元素肯定处于中间元素的左边部分或是右边部分，于是我们一下子可以把搜索范围缩小一半。由于每次查找都可以把范围缩小一半，因此无需几次操作，我们就可以确认数组是否含有给定元素。

基于二分查找法的重要作用，算法面试官往往都希望候选人拥有掌握它的能力。在考察时，面试官都希望候选人能以简短的代码来实现二分查找的功能。然而在实现上，编写二分查找法的代码是及其容易出错的，你必须注意各种边界条件的处理，例如数组是空的，或者数组只有一个元素等等。别说你会出错，很多正规出版的算法书在讲解二分查找法时，他们给出的代码也是有错误的，据统计在美国出版的二十多本不同的讲算法的书中，只有五本对二分查找的代码实现是正确的。

《编程珠玑》一书的作者Jon Bentley在该书中做过统计，让专业的开发人员实现二分查找法的代码，在给予他们充足时间的情况下，有百分之九十以上的人无法编写出完全准确的代码。搞笑的是，《编程珠玑》中有一章讲“如何正确的编写代码”("writing correct programs")，其中作者专门以二分查找法的实现为例，用来教育读者如何把代码写对，讽刺的是这段实现二分查找的样板代码，其中包含一个bug,在这本书出版的二十多年里都没有被人发现。我截取书中相关内容让大家看看：

这里写图片描述

这段文字摘录于全书（中文）第四章“编写正确的代码”，位于第34页。上面那段伪码是用来实现二分查找功能的，大家看的出来Bug隐藏在哪吗。问题出现在这句： m = (l + u) / 2; 这句会造成计算溢出。假设代码跑在32位的机器上，那么整形最大值只能用32位比特位来表示，如果l 和 u 是两个很大的整数，他们相加后的结果如果超过32位的话就会造成计算溢出，也就是超出32位的比特位会被抛弃，于是计算出来的结果就是错误的，合理的做法是改成下面这种方式：
m = l + (u - l ) / 2;

接下来我们先给出java对二分查找法的实现，然后分析有关二分查找法的面试算法题：

public int binarySearch(int[] A, int B, int E, int t) {
        int L = B, U = E;
        while (L <= U) {
            /*
             * 在名著《编程珠玑》中的实现是
             * M = (U+L)/2
             * 这种做法会导致数值计算溢出，假设代码运行在32位机器上，如果U 和 L 的值足够大，两者相加之后的值超过32位的话，
             * U+L 会导致计算溢出，超出32位以上的比特位可能会被丢弃，于是U+L会得到比预期结果要小的多的值
             * 虽然 M = L + (U - L) / 2 在某些情况下也有问题，但由于使其出错的情况很罕见，所以我们暂时使用这个办法
             */
            int M = L + (U - L) / 2;
            
            if (A[M] < t) {
                L = M + 1; 
            } else if (A[M] == t) {
                return M;
            } else {
                U = M - 1;
            }
            
        }
        
        return -1;
    }

代码中参数B表示begin,也就是查找的起始位置，E表示end,也就是查找的结束位置。接下来我们看看一道有关二分查找的算法题。

给定一个排好序的整形数组A,以及一个值K,返回K在数组A中第一次出现的位置，如果A不包含K,那么返回-1,例如给定数组A：
-14, -10, 2, 108, 108, 243, 285, 285, 285, 401
如果k = 285, 那么你返回它在数组中第一次出现的位置6.

由于数组是排序的，我们可以用二分查找法先找到给定数值在数组中出现的位置，但由于数组中包含重复元素，因此第一次找到的未必是它在数组中第一次出现的位置，假设第一次用二分法找到的位置是P, 那么我们可以在数组的0到P-1个元素中，再次使用二分法查找，看看这部分元素还有没有包含给定值，如果有，那么在从位置0到查找到的位置前一个元素间的所有元素间再次使用二分法查找，直到找不到为止。

基于本例，假设第一次使用二分法找到的285位置是7，那么我们把下标0到6之间的元素再次使用二分法查找，于是能找到下标为6的元素也是285，然后再在下标从0到5的元素使用二分法查找，这次查找会失败，由此我们可以得到，285首次出现在数组中的下标是6.实现代码如下：

public void findFirstApperance() {
        int[] A = new int[]{-14, -10, 2, 108, 108, 243, 285, 285, 285, 401};
        int t = 285;
        int k = this.binarySearch(A, 0, A.length - 1, t);
        while (true) {
            int temp = this.binarySearch(A, 0, k - 1, t);
            if (temp != -1 && temp < k) {
                k = temp;
            } else {
                break;
            }
        }
        
        System.out.println("The first apperance of " + t + " is at index " + k);
    }

由于折半查找使得查找的元素个数都减半，因此含有n个元素的数组，能折半的次数是lg(n), 折半后，要对一半元素进行遍历，复杂度是O(n),所以上面算法的时间复杂度是O(n * lg(n))

我们再看一道难一点的，关于二分查找法的变种算法题：
绝对值排序数组，在数组中的值是根据他们的绝对值来排序的，也就是说给定下标i,j 如果i < j, 那么有|A[i]| < |A[j]|, 例如下面给定的数组就是绝对值排序的：
-49, 75, 103, -147, 164, -197, -238, 314, 348, -422

给定一个绝对值排序的数组A，并给定一个数值K，要求你判断，数组中是否含有两个元素，他们的加起来的和等于给定的数值K。例如根据上面的数组，并给定数值K = 167, 那么A[3] + A[7] = K, 也是算法返回这两个下标(3, 7),如果不存在这样的两个数，算法返回(-1, -1)。

我们先看看，如果给定一个全是整形的数组，并给定一个值，看看如何判断数组中是否含有两个元素，他们加起来等于给定值。假设给定数组如下：
1, 2, 3, 4, 5, 6, 7, 8, 9

并给定数值14， 你如何找出两个元素，他们之和等于14？做法如下，先拿出第一个元素1，用14减去1得13，然后用二分查找法在剩下的元素里查找看看是否包含13，如果没有，那么拿出第二个元素2，用14减2得12，然后在剩下的元素中使用二分查找看看有否包含12，以此类推，如果所有元素都遍历完后没有结果，那表明数组中不包含符合条件的元素。使用这个办法，我们可以从数组中找到5和9两个元素是满足条件的。

由于绝对值排序的数值含有负数，我们不能直接使用上面的办法，但只要我们把该数组转变为只包含正整数的数组，就可以使用上面的方法了。根据绝对值排序数组的特点，最后一个元素的绝对值肯定是最大的，于是我们可以把数组中的每个元素都加上最后一个元素的绝对值。假设最后一个元素的绝对值是M,那么处理后，数组中全是正整数，同时他们相加的结果比原来大2M, 我们把原来要查找的数值K 也转变为 K + 2*M,于是原来的问题就变成在新数组下，查找是否有两个元素，他们之和等于K + 2*M, 这两个元素对应的旧元素，他们之和肯定就等于K, 由于数组中包含的都是正整数，所以我们可以使用上面的方法来处理这个问题，因此代码如下：

public Entry findPairInAbsSortedArray() {
        int[] A = new int[] {-49, 75, 103, -147, 164, -197, -238, 314, 348, -422};
        int t = 167;
        Entry e = new AbstractMap.SimpleEntry(-1, -1);
        
        t += 2 * Math.abs(A[A.length - 1]);
        for (int i = 0; i < A.length; i++) {
            A[i] += Math.abs(A[A.length - 1]);
        }
        
        for (int i = 0; i <= A.length - 2; i++) {
            int v = t - A[i];
            int k = this.binarySearch(A, i+1, A.length - 1, v);
            if (k != -1) {
                e = new AbstractMap.SimpleEntry(i, k);
                break;
            }
        }
        
        return e;
    }

如果绝对值排序数组中含有给定元素，那么相关元素的下标会存储到Entry中，如果没有，Entry中的值是两个-1.该算法的时间复杂度仍然是O(n * lg(n)).

更详细的代码调试和讲解请参看视频：
如何进入google,算法面试技能全面提升指南

更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：

这里写图片描述