从m个数字中选取前n个最小的

import java.util.Arrays;
import java.util.Random;

public class Test {
    static int m = 10000000;

    static int n = 10000;

    static int[] bigArr = new int[m];

    static Random random = new Random();

    /**
     * Description: 从m个数字中选取前n个最小的<br> 
     *  
     * @author wang.yueyang<br>
     * @param args <br>
     */ 
    public static void main(String[] args) {
        int i = 0;
        for (; i < m; i++)
            bigArr[i] = random.nextInt(m);
        
        int[] arr1 = edu.emory.mathcs.backport.java.util.Arrays.copyOf(bigArr, m);
        int[] arr2 = edu.emory.mathcs.backport.java.util.Arrays.copyOf(bigArr, m);
        int[] arr3 = edu.emory.mathcs.backport.java.util.Arrays.copyOf(bigArr, m);
        show(1, arr1, n);
        show(2, arr2, n);
        show(3, arr3, n);
        show(0, bigArr, m);
    }

    /**
     * Description: 展示数据并计算耗时<br> 
     *  
     * @author wang.yueyang<br>
     * @param idx
     * @param arr
     * @param length <br>
     */ 
    public static void show(int idx, int[] arr, int length) {
        int[] result = null; 
        long begin = System.currentTimeMillis();
        switch (idx) {
            case 1:
                result = method1(arr, length);
                break;
            case 2:
                result = method2(arr, length);
                break;
            case 3:
                result = method3(arr, length);
                break;

            default:
                result = arr;
                break;
        }
        long end = System.currentTimeMillis();
        System.out.println("method" + idx + "took time = " + (end - begin));
        for (int i : result)
            System.out.print(i + ",");
        System.out.println();
    }

    /**
     * Description: 从m个中选择最小的一个放到n[0]中，然后从剩下的m-1个中选择最小的放到n[1]中
     * 依次选择前n个最小的，时间复杂度为l*r<br> 
     *  
     * @author wang.yueyang<br>
     * @param bigArr
     * @param length
     * @return <br>
     */ 
    public static int[] method1(int[] bigArr, int length) {
        int i = 0;
        int j;
        int[] result = new int[length];
        int index = 0;
        for (; i < length; i++) {
            for (j = i + 1; j < bigArr.length; j++) {
                if (bigArr[index] > bigArr[j])
                    index = j;
            }
            result[i] = bigArr[index];
            bigArr[index] = bigArr[i];
            bigArr[i] = result[i];
        }
        return result;
    }
    
    /**
     * Description: 先做排序，然后截取前n个最小的，时间复杂度要看选择的排序算法了，选用快排为mlog(m)<br> 
     *  
     * @author wang.yueyang<br>
     * @param bigArr
     * @param length
     * @return <br>
     */ 
    public static int[] method2(int[] bigArr, int length) {
        Arrays.sort(bigArr);
        return Arrays.copyOf(bigArr, length);
    }
    
    /**
     * Description:先从m中取n个作为最小值，遍历剩余的m-n个
     * 计算选取的n个中的最小值，如果比选取的n个中最大的还小，则交换两个值，保持n中为最小的 <br> 
     *  
     * @author wang.yueyang<br>
     * @param bigArr
     * @param length
     * @return <br>
     */ 
    public static int[] method3(int[] bigArr, int length) {
        int[] result = Arrays.copyOf(bigArr, length);
        int i = length;
        int index = 0;
        int j;
        for (; i < bigArr.length; i++) {
            for (index = 0, j = 1; j < length; j++) {
                if (result[index] < result[j])
                    index = j;
            }
            if (bigArr[i] < result[index]) {
                result[index] = bigArr[i];
            }
        }
        return result;
    }
    
    /**
     * Description:先从m中取n个作为最小值，遍历剩余的m-n个
     * 如果上一次发生交换，则计算选取的n个中的最小值，否则，不用计算。
     * （相对于method3的优化，就是在这个地方，可以有效减少n中最小值的计算次数）
     * 如果比选取的n个中最大的还小，则交换两个值，保持n中为最小的 <br> 
     *  
     * @author wang.yueyang<br>
     * @param bigArr
     * @param length
     * @return <br>
     */ 
    public static int[] method4(int[] bigArr, int length) {
        int[] result = Arrays.copyOf(bigArr, length);
        int i = length;
        int index = 0;
        int j;
        boolean changeFlag = true;
        for (; i < bigArr.length; i++) {
            if (changeFlag)
                for (index = 0, j = 1; j < length; j++) {
                    if (result[index] < result[j])
                        index = j;
                }
            if (bigArr[i] < result[index]) {
                result[index] = bigArr[i];
                changeFlag = true;
            }
            else
                changeFlag = false;
        }
        return result;
    }
}