编程之美-得到无序数组中最大K个数

原文看这里：

题目描述：
问：有很多个无序的数，我们姑且假定他们各不相等，怎么选出其中最大的若干个数呢？
答：可以这样写：int array[100] 。。。
问：好，如果有更多的数呢？
答：那可以改为 int array[1000] ...
问：如果我们有很多的数，比如一亿个，怎么办？
答：我们可以写 float array[100000000] 。。。
问：这样的程序能编译运行吗？
答：嗯... 我没写过那么多的0 .....


以下是各种实现的代码，我们就不用1亿个数字测试了，如果真的有那么多，保存为文件，用InputStream一边读取，一边处理好了：

注意：代码里面的大部分for循环，都可以改成从InputStream进行读取，int[]参数也是一样。这样就可以处理大数据量了。

1. import java.util.ArrayList;
2. import java.util.Collections;
3. import java.util.List;
5. /**
6.  * 得到无序数组的最大的K个数据。
7.  * 
8.  * @author 老紫竹 java2000.net
9.  */
10. public class ArrayFind {
11.   public static void main(String[] args) {
12.     int[] arrNum = { 1, 5, 8, 3, 5, 87, 2, 5, 6, 8, 49, 5, 2, 26, 16, 33, 1, 36, 5, 65, 13, 3, 34,
13.         24, 2, 36, 474, 4, 4 };
14.     List<Integer> arr = new ArrayList<Integer>(arrNum.length);
15.     for (int num : arrNum) {
16.       arr.add(num);
17.     }
18.     List<Integer> arrBak = new ArrayList<Integer>(arr);
19.     int k = 5;
20.     find1(arr, k);
21.     //
22.     //
23.     arr.clear();
24.     arr.addAll(arrBak);
25.     List<Integer> rtn = find2(arr, k);
26.     for (int num : rtn) {
27.       System.out.print(num + ",");
28.     }
29.     System.out.println();
30.     //
31.     //
32.     arr.clear();
33.     arr.addAll(arrBak);
34.     find3(arr, k);
35.     //
36.     //
37.     arr.clear();
38.     arr.addAll(arrBak);
39.     List<Integer> rtn4 = find4(arr, k);
40.     for (int num : rtn4) {
41.       System.out.print(num + ",");
42.     }
43.     System.out.println();
44.   }
46.   /**
47.    * 标准排序算法。
48.    * 
49.    * @param arr
50.    * @param k
51.    */
52.   public static void find1(List<Integer> arr, int k) {
53.     Collections.sort(arr);
54.     for (int i = arr.size() - 1; i > arr.size() - k - 1; i--) {
55.       System.out.print(arr.get(i) + ",");
56.     }
57.     System.out.println();
58.   }
60.   /**
61.    * 大小组分组方法。
62.    * 
63.    * @param S
64.    * @param k
65.    * @return
66.    */
67.   public static List<Integer> find2(List<Integer> S, int k) {
68.     if (k <= 0) {
69.       return new ArrayList<Integer>();
70.     }
71.     if (S.size() <= k) {
72.       return S;
73.     }
74.     List<Integer>[] rtn = Partition(S);
75.     List<Integer> Sa = rtn[0];
76.     List<Integer> Sb = rtn[1];
77.     List<Integer> R = find2(Sa, k); // 找大的一组里面最大的k个
78.     if (Sa.size() < k) {// 如果大的分组不足，则加上小的一组里面不够的数量
79.       R.addAll(find2(Sb, k - Sa.size()));
80.     }
81.     return R;
82.   }
84.   private static List<Integer>[] Partition(List<Integer> S) {
85.     ArrayList<Integer> Sa = new ArrayList<Integer>();
86.     ArrayList<Integer> Sb = new ArrayList<Integer>();
87.     int p = S.get(0);
88.     int element;
89.     for (int i = 1; i < S.size(); i++) {
90.       element = S.get(i);
91.       if (element > p) {
92.         Sa.add(element);
93.       } else {
94.         Sb.add(element);
95.       }
96.     }
97.     if (Sa.size() < Sb.size()) {
98.       Sa.add(p);
99.     } else {
100.       Sb.add(p);
101.     }
102.     ArrayList<Integer>[] rtn = new ArrayList[2];
103.     rtn[0] = Sa;
104.     rtn[1] = Sb;
105.     return rtn;
106.   }
108.   public static List<Integer> find3(List<Integer> S, int K) {
109.     double Vmin = 0;
110.     double Vmax = 1000;
111.     double delta = 0.5;
112.     double Vmid;
113.     while (Vmax - Vmin > delta) {
114.       Vmid = Vmin + (Vmax - Vmin) * 0.5;
115.       int count = 0;
116.       for (int n : S) {
117.         if (n >= Vmid)
118.           count++;
119.         if (count >= K)
120.           break;
121.       }
122.       if (count >= K) {
123.         Vmin = Vmid;
124.       } else {
125.         Vmax = Vmid;
126.       }
127.     }
128.     for (int s : S) {
129.       if (s > Vmin) {
130.         System.out.print(s + ",");
131.       }
132.     }
133.     System.out.println();
134.     return null;
135.   }
137.   /**
138.    * 使用一个长度为K的小列表。
139.    * 
140.    * @param S
141.    * @param K
142.    * @return
143.    */
144.   public static List<Integer> find4(List<Integer> S, int K) {
145.     List<Integer> rtn = new ArrayList<Integer>(K);
146.     for (int i = 0; i < K; i++) {
147.       rtn.add(S.get(i));
148.     }
149.     Collections.sort(rtn);
150.     int min = rtn.get(0);
151.     int current;
152.     for (int i = K; i < S.size(); i++) {
153.       current = S.get(i);
154.       if (current > min) {
155.         rtn.remove(0);
156.         rtn.add(current);
157.         Collections.sort(rtn);
158.         min = rtn.get(0);
159.       }
160.     }
161.     return rtn;
162.   }
163. }

运行结果
474,87,65,49,36,
474,87,65,49,36,
87,49,36,65,36,474,
36,49,65,87,474,