最大N算法（前一版本的改进）

 

 

MaxNAlgorithm比最简单的排序后取最大的n位， 效率高十陪以上（当然需排序数组也要有足够大且n与数组大小差距足够大才行； 测试结果只是个比较而已，因为vm没有先预热以及相应参数配置）。

最简单的排序后取最大的n位： array size 乘于 array size 的比较。

MaxNAlgorithm：n 乘于 array size 的比较。

 

这个算是对前一版本的改进：

因为之前直接利用PriorityQueue实现了一个（效率只提高三陪以上）

http://blog.csdn.net/yang_net/archive/2010/10/24/5962010.aspx

 

 

1。 算法实现

 

/**
 *
 */
package algorithm.max;

import java.util.Arrays;

/**
 * Max N Primitive Algorithm
 *
 * @author yangwm Nov 1, 2010 9:25:02 PM
 */
public class MaxNAlgorithmPrimitive {

    /**
     * max + n
     *
     * @param <int>
     * @param input
     * @param n
     * @return
     */
    public static int[] max(int[] input, int n) {
        if (n > input.length) {
            n = input.length;
        }
        
        int[] result = new int[n];
        int[] temp = Arrays.copyOf(input, n);
        Arrays.sort(temp);
        for (int i = temp.length - 1, resultIdx = 0; i >= temp.length - n; i--) {
            result[resultIdx++] = temp[i];
        }
        //System.out.println(Arrays.toString(result));
        
        for (int i = n; i < input.length; i++) {
            add(input[i], result);
        }
        return result;
    }

    /**
     * add
     *
     * 使用orderPosition效率高于binaryPosition
     *
     * @param <E>
     * @param x
     * @param result
     * @param comparator
     */
    private static <E> void add(E x, E[] result, Comparator<? super E> comparator) {
        int k = orderPosition(x, result, comparator); // binaryPosition(x, result, comparator);

        /*
         * 根据返回的数组下标交换位置 （让x元素排在比它的小的元素前面）
         */
        if (k < result.length - 1) {
            int srcIdx = k + 1;
            if (srcIdx != result.length - 1) { // 已经是最后一位不需要移动整个数组
                int destIdx = srcIdx + 1; // 后移一位  
                System.arraycopy(result, srcIdx, result, destIdx, result.length - destIdx);
            }
            result[srcIdx] = x;
        }
    }
    
    /**
     * 由小到大定位：找出大于等于x元素的数组下标，没有大于等于x元素则返回-1
     *
     * @param <int>
     * @return
     */
    private static int orderPosition(int x, int[] result) {
        //System.out.println("binaryPosition:" + x + ", " + Arrays.toString(result));
        
        int k = result.length - 1;

        while (k >= 0) {
            int e = result[k];
            //System.out.println("result[" + k + "]=" + e);
            if (x >= e) {
                k--;
            } else {
                break;
            }
        }
        
        //System.out.println("k:" + k);
        return k;
    }
    /**
     * 二分定位：找出大于等于x元素的数组下标，没有大于等于x元素则返回-1
     * Arrays.binarySearch的变体
     *
     * @param <E>
     * @param x
     * @param result
     * @param comparator
     * @return
     */
    private static int binaryPosition(int x, int[] result) {
        //System.out.println("binaryPosition:" + x + ", " + Arrays.toString(result));
        
        int k = -1;
        
        int left = 0;
        int right = result.length - 1;
        while (left <= right) {
            int mid = (left + right) >>> 1;
            int midVal = result[mid];

            if (x < midVal) {
                left = mid + 1;
            } else if (x > midVal) {
                right = mid - 1;
            } else {
                break;
            }
        }
        
        k = left - 1;
        //System.out.println("k:" + k);
        return k;  // key not found.
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] input = new int[] { 2, 7, 6, 8, 9, 18, 11, 5, 3, 20 };
        int n = 3;
        System.out.println("------MaxNPrimitiveAlgorithm Array max n-------");

        int[] result = max(input, n);
        System.out.println(Arrays.toString(result));
    }

}

 

 

package algorithm.max;

import java.util.Arrays;

/**
 * top n algorithm
 *
 * 算法来自一道面试题注记 - 庄周梦蝶 - BlogJava
 * http://www.blogjava.net/killme2008/archive/2010/10/28/336357.html
 *
 * @author yangwm Oct 31, 2010 6:39:46 PM
 */
public class TopNAlgorithm {
   
    /**
     * 求数组的前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;
        }
        if (i > r - p + 1 || i < 0)
            throw new IllegalArgumentException();
        // 划分
        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 int partition(int a[], int p, int r) {
        int x = a[r];
        int i = p - 1;

        for (int j = p; j < r; j++) {
            if (a[j] < x) {
                i++;
                int temp = a[j];
                a[j] = a[i];
                a[i] = temp;
            }
        }
        int temp = a[i + 1];
        a[i + 1] = a[r];
        a[r] = temp;
        // System.out.println((i+1-p)+" "+(r-i-1));
        return i + 1;

    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] input = new int[] { 2, 7, 6, 8, 9, 18, 11, 5, 3, 20 };
        int n = 3;
        System.out.println("------TopNAlgorithm Array findTopNValues n-------");

        int[] result = findTopNValues(input, n);
        System.out.println(Arrays.toString(result));
    }

}

/*
------TopNAlgorithm Array findTopNValues n-------
[18, 20, 11]

*/

 

 

/**
 *
 */
package algorithm.max;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Max N Algorithm Primitive Bench
 *
 * @author yangwm Nov 1, 2010 9:25:14 PM
 */
public class MaxNAlgorithmPrimitiveBench {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /*
         *
         */
        int inputTotal = 10000000;
        int n = 10;
       
        /*
         * test data
         */
        List<Integer> inputList = new ArrayList<Integer>(inputTotal);
        for (int i = 0; i < inputTotal; i++) {
            inputList.add(i);
        }
        Collections.shuffle(inputList);
        System.out.println("test begin inputTotal: " + inputTotal + ", n: " + n);
        System.out.println("test data inputList.size(): " + inputList.size());
       
       
        //-----------------------------------------------------------------

        int[] inputArray = new int[inputList.size()];
        for (int i = 0; i < inputArray.length; i++) {
            inputArray[i] = inputList.get(i);
        }
        System.out.println("-------JDK Arrays.sort max n-------");
       
        /*
         * max and test print
         */
        long begin = System.currentTimeMillis();
        Arrays.sort(inputArray);
        int[] resultArray = new int[n];
        for (int i = inputArray.length - 1, resultIdx = 0; i >= inputArray.length - n; i--) {
            resultArray[resultIdx++] = inputArray[i];
        }
        long end = System.currentTimeMillis();
        System.out.println("cosume: " + (end - begin) + " ms");
        System.out.println("resultArray.length: " + resultArray.length);
        System.out.println("resultArray of first ten : " + Arrays.toString(resultArray));


        //-----------------------------------------------------------------

        inputArray = new int[inputList.size()];
        for (int i = 0; i < inputArray.length; i++) {
            inputArray[i] = inputList.get(i);
        }
        System.out.println("-------MaxNAlgorithmPrimitiveBench Array top n-------");
       
        /*
         * max and test print
         */
        begin = System.currentTimeMillis();
        resultArray = MaxNAlgorithmPrimitive.max(inputArray, n);
        end = System.currentTimeMillis();
        System.out.println("cosume: " + (end - begin) + " ms");
        System.out.println("resultArray.length: " + resultArray.length);
        System.out.println("resultArray of first ten : " + Arrays.toString(resultArray));


        //-----------------------------------------------------------------

        inputArray = new int[inputList.size()];
        for (int i = 0; i < inputArray.length; i++) {
            inputArray[i] = inputList.get(i);
        }
        System.out.println("-------TopNAlgorithmBench Array top n-------");
       
        /*
         * max and test print
         */
        begin = System.currentTimeMillis();
        resultArray = TopNAlgorithm.findTopNValues(inputArray, n);
        end = System.currentTimeMillis();
        System.out.println("cosume: " + (end - begin) + " ms");
        System.out.println("resultArray.length: " + resultArray.length);
        System.out.println("resultArray of first ten : " + Arrays.toString(resultArray));

    }
}

/*
test begin inputTotal: 10000000, n: 10
test data inputList.size(): 10000000
-------JDK Arrays.sort max n-------
cosume: 1781 ms
resultArray.length: 10
resultArray of first ten : [9999999, 9999998, 9999997, 9999996, 9999995, 9999994, 9999993, 9999992, 9999991, 9999990]
-------MaxNAlgorithmPrimitiveBench Array top n-------
cosume: 78 ms
resultArray.length: 10
resultArray of first ten : [9999999, 9999998, 9999997, 9999996, 9999995, 9999994, 9999993, 9999992, 9999991, 9999990]
-------TopNAlgorithmBench Array top n-------
cosume: 141 ms
resultArray.length: 10
resultArray of first ten : [9999996, 9999998, 9999999, 9999997, 9999991, 9999993, 9999992, 9999994, 9999995, 9999990]

*/