javaeye的一個帖子介紹一道面試題，取數組的最大元素和前n個大元素，取最大元素很簡單，遍歷即可。取前N大元素，可以利用排序，最簡單的實現：

[java] public static int[] findTopNValues(int[] anyOldOrderValues, int n) { Arrays.sort(anyOldOrderValues); int[] result = new int[n]; System.arraycopy(anyOldOrderValues, anyOldOrderValues.length – n, result, 0, n); return result; } [/java]

Arrays.sort(int[])使用的是快排，平均的時間復雜度是O(nlg(n))，在一般情況下已經足夠好。那么有沒有平均情況下O(n)復雜度的算法？這個還是有的，這道題目其實是選擇算法的變形，選擇一個數組中的第n大元素，可以采用類似快排的方式劃分數組，然后只要在一個子段做遞歸查找就可以，平均狀況下可以做到O(n)的時間復雜度，對于這道題來說稍微變形下算法即可解決：

[java] /** * 求數組的前n個元素 * * @param anyOldOrderValues * @param n * @return */ public static int[] findTopNValues(int[] anyOldOrderValues, int n) { int[] result = new int[n]; findTopNValues(anyOldOrderValues, 0, anyOldOrderValues.length – 1, n, n, result); return result; } public static final void findTopNValues(int[] a, int p, int r, int i, int n, int[] result) { // 全部取到，直接返回 if (i == 0) return; // 只剩一個元素，拷貝到目標數組 if (p == r) { System.arraycopy(a, p, result, n – i, i); return; } int len = r – p + 1; if (i > len || i < 0) throw new IllegalArgumentException(); // if (len < 7) { // Arrays.sort(a, p, r+1); // System.arraycopy(a, r – i+1 , result, n – i, i); // return; // } // 劃分 int q = medPartition(a, p, r); // 計算右子段長度 int k = r – q + 1; // 右子段長度恰好等于i if (i == k) { // 拷貝右子段到結果數組，返回 System.arraycopy(a, q, result, n – i, i); return; } else if (k > i) { // 右子段比i長，遞歸到右子段求前i個元素 findTopNValues(a, q + 1, r, i, n, result); } else { // 右子段比i短，拷貝右子段到結果數組，遞歸左子段求前i-k個元素 System.arraycopy(a, q, result, n – i, k); findTopNValues(a, p, q – 1, i – k, n, result); } } public static int medPartition(int x[], int p, int r) { int len = r – p + 1; int m = p + (len >> 1); if (len > 7) { int l = p; int n = r; if (len > 40) { // Big arrays, pseudomedian of 9 int s = len / 8; l = med3(x, l, l + s, l + 2 * s); m = med3(x, m – s, m, m + s); n = med3(x, n – 2 * s, n – s, n); } m = med3(x, l, m, n); // Mid-size, med of 3 } if (m != r) { int temp = x[m]; x[m] = x[r]; x[r] = temp; } return partition(x, p, r); } private static int med3(int x[], int a, int b, int c) { return x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a) : x[b] > x[c] ? b : x[a] > x[c] ? c : a; } public static void swap(int[] a, int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } public static int partition(int a[], int p, int r) { int x = a[r]; int m = p – 1; int j = r; while (true) { do { j–; } while (j>=p&&a[j] > x); do { m++; } while (a[m] < x); if (j < m) break; swap(a, m, j); } swap(a, r, j + 1); return j + 1; } [/java]

選擇算法還有最壞情況下O(n)復雜度的實現，有興趣可以讀算法導論和維基百科。題外，我測試了下這兩個實現，在我的機器上大概有2倍多的差距，還是很明顯。

轉載于:https://blog.51cto.com/aliapp/1327633

總結

以上是生活随笔為你收集整理的一道面试题注记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。