面试算法：快速获取数组中点的相邻区域点

假设给定一个数组A,要求你找到数组的中点，并且将离中点最近的k个数组成员抽取出来。例如数组A={7, 14, 10, 12, 2, 11, 29, 3, 4}，该数组的中点是10，如果令k=5,那么里中点最近的5个数就是{7,14,10,12,11}.

要求对任意一个数组，设计一个时间复杂度为O(n)的算法，该算法能找出距离数组中点最近的K个元素。

这道题的难度是比较大的，在面试中出现的概率应该不大，如果你能在一小时内把它解决并给出代码，那么你的水平在BAT中当个技术经理以上的职位应该是没有太大问题的。

解决这个问题要分两步走：
1， 找到一个算法，能够让我们在O(n)的时间内查找到数组的中点。

2， 假设我们找到了中点m, 那么我们把计算数组前k个元素与中点m的距离，也就是 d(i) = |A[i] - m|, 把这k个元素与中点的距离构建一个大堆。接着在剩下的n - k 个元素中，我们逐次计算他们与中点m的距离，然后用这个距离与大堆中的最大值相比较，如果这个距离大过大堆返回的最大值，那么就忽略这个元素，如果它的距离比大堆的最大值小，那么就把大堆中的最大值去掉，将当前元素加入大堆。

当完成步骤2之后，大堆中的k个元素就是距离终点最近的K个元素。在第二步中，我们需要把元素加入一个大堆，对于一个含有k个元素的大堆而言，加入一个元素的复杂度是O(lgk)，所以执行第二步所需的时间复杂度是O(n * lgk)。 由于k是一个常数，所以第二步相对于变量n来说，也是线性的。

现在问题在于第一步的实现，也就是如何通过线性时间的算法找到一个数组的中点，事实上，只要找到第一步的算法，那么整个问题就可以解决了，本质上第二步是多余的，所以本文的重点将在对一步的分析上。我们看看如何设计一个算法，使得我们能在O(n)的时间复杂度内，在数组中找到任意第k大的元素。显然，数组中点是数组中第n/2大的元素，于是要解决问题，我们只要找到第(n/2-k/2)大的元素，然后再找到(n/2+k/2)大的元素，最后查找所有处于这两者之间的元素，那么问题就解决了。

我们看看如何在O(n)的时间内，找到数组中第i大的元素，它的算法步骤如下：
1， 把n个元素分成若干个小组，每个小组有5个元素，于是总共能分成n/5组
2， 对每个小组中的五个元素进行排序，然后取出他们的中点。
3， 利用本算法递归的去查找步骤2中所有中点组成的集合中的中点，假定得到的中点为x。
4， 根据步骤4得到的x把数组划分为两部分，把所有小于x的元素放到x的左边，把所有大于x的元素放到x的右边。假设x的左边有k-1个元素，那么x就是第k小的元素，在x的右边就有n-k个元素。
5, 如果i == k, 那么直接返回x, 如果 i < k, 那么我们在x左边元素集合中，递归的使用该算法去查找第i 小的元素。如果i > k, 那么我们在x的右边元素集合中，使用该算法去查找第(i - k)小的元素。

该算法的实现代码如下：

int select(int[] A, int i) {       //在数组中查找第i小的元素      if (A.length == 1) {          return A[0];      }       /*        * 步骤1，将数组分成小组，每个小组含有5个元素,最后一组很可能没有5个元素        */       ArrayList<int[]> arrCollection = new ArrayList<int[]>();       int p = 0;       int cnt = 5;       int[] arr = null;       while (p < A.length) {           if (cnt >= 4) {               int len = Math.min(5, A.length - p);               arr = new int[len];               cnt = 0;               arrCollection.add(arr);           } else {               cnt++;           }           arr[cnt] = A[p];           p++;       }       /*        * 步骤2，把每个小组中的元素排序，并取出每个小组中的中点        */       int[] medians = new int[arrCollection.size()];       for (int j  = 0; j < arrCollection.size(); j++) {           Arrays.sort(arrCollection.get(j));           arr = (int[])arrCollection.get(j);           medians[j] = arr[arr.length / 2];       }       /*        * 步骤3，递归的去获取中点集合中的中点        */       int x = select(medians, medians.length/2);       /*        * 步骤4，把小于x的元素放到x左边，把大于x的元素放到x的右边        */       int[] B = new int[A.length];        int begin = 0, end = A.length - 1;       int pos = 0;       while (pos < A.length) {           if (A[pos] < x) {               B[begin] = A[pos];               begin++;           }           if (A[pos] > x) {               B[end] = A[pos];               end--;           }           pos++;       }       B[begin] = x;       A = B;       /*        * 执行步骤5，如果x左边的元素是k-1个，同时i == k, 那么返回x        * 如果i < k, 那么递归的去在左边k-1个元素中查找第i小的元素        * 如果i > k, 那么递归的在右边n-k个元素中，查找第(i - k)小的元素        */       if (i == begin) {           return x;       } else if (i < begin) {           arr = Arrays.copyOf(A, begin);           return select(arr, i);       } else {           arr = Arrays.copyOfRange(A, begin+1, A.length);           return select(arr, i - begin - 1);       }   }

我们简单对算法进行分析一下：
第一步是把元素分成若干个小组，一次循环就可以完成，所以复杂度是O(n);

第二步是找到每个小组中的中点，由于每个小组只有5个元素，所以第二步的时间复杂度也是O(n);

第三步是在所有中点的集合中再找出中点，这一步涉及到算法的递归，所以我们暂时不做分析。

第四步是把数组元素分成两部分，所需时间复杂度也是O(n)。

第五步是在数组中的某一个子集中再次递归的运行算法。

我们看看执行第3步后，也就是取到中点的中点，假设中点的中点为x，然后我们会把数组元素根据x分成两部分：

我们看上图，假设中间点x是我们找到的中点集合中的中点，这样右下角阴影部分的节点，他们的值肯定是大于x的。因为我们把所有节点分成若干个小组，每个小组有5个点，最后一个小组有可能不足5个元素，所有去掉包含x的那个小组，以及最后一个小组，那么就有 (1/2 * n/5) 个小组中，下半部的三个节点都会大于x.于是大于x的元素的个数就至少有：

3* [ (1/2 *n/5) - 2] = 3n/10 - 6 个。

如果我们要找的元素处于前半部分，那么前半部分的元素个数最多有 n - (3n/10 - 6) = 7n/10 + 6 个，如果处于后半部分，那么要处理的元素就有3n/10 - 6 个，也就是说，当我们执行第5步的时候，递归处理的元素个数最多不超过7n/10 + 6个。

我们不深入更加细致的复杂度分析，可以保证的是，算法的最终复杂度是O(n), 也就是说依靠上面算法实现，我们可以在线性时间内从数组中查找处于任意位置的元素。

根据给定的数组A = {7, 14, 10, 12, 2, 11, 29, 3, 4}, 它排序后为：{2, 3, 4, 7, 10, 11, 12, 14, 29}，于是第0小的元素是2，第8小的元素是29.如果运行代码：
int y = select(A, 8);

那么我们得到的y值就是29。对代码更详细的讲解和调试演示，请参看视频：

如何进入google,算法面试技能全面提升指南

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