TopK算法性能对比

TopK算法性能对比

从arr[1, n]这n个数中，找出最大的k个数，这就是经典的TopK问题。 笔者将 使用冒泡算法和小顶堆实现TopK，对比其时间复杂度。

冒泡算法实现

不需要将数据全部排序，只用排k轮即可。

import java.util.Arrays;


// topK 冒泡法 效率 O(kn)
public class TopKBubble {

    public static int[] topK(int[] arr, int k) {

        for (int i = 0; i < k; i++)
            for (int j = 0; j < arr.length - 1 - i; j++)
                if (arr[j] > arr[j + 1])
                    swap(arr, j, j + 1);

        return Arrays.copyOfRange(arr, arr.length - k, arr.length);
    }
    
    public static void swap(int[] arr, int index1, int index2) {

        arr[index1] = arr[index2] ^ arr[index1];
        arr[index2] = arr[index2] ^ arr[index1];
        arr[index1] = arr[index2] ^ arr[index1];
    }
}

可见时间复杂度O( k*n)

小顶堆实现

堆：一种数据结构，有最大堆和最小堆两种类型，实质上是一个完全二叉树，如果是最大堆，则父节点上的值比子节点上的值大，反之则是最小堆。而堆排序是一种比较高效的排序方式，时间效率为N*lgN，它利用最大堆的特性完成排序。

import java.util.Arrays;


//topK 最小堆实现方式 效率 O( (n-k)log2(k) )
public class TopKHeap {

    public static int[] topK(int[] arr, int k) {

        buildHeap(arr, k);

        for (int i = k; i < arr.length; i++)
            if (arr[0] < arr[i]) {
                arr[0] = arr[i];
                buildHeap(arr, k);
            }

        return Arrays.copyOfRange(arr, 0, k);
    }

    public static void buildHeap(int[] arr, int size) {

        for (int i = size - 1; i >= 0; i--)
            reBuildHeap(arr, i, size);
    }

    public static void reBuildHeap(int[] arr, int key, int size) {

        int leftChild = (key << 1) + 1;
        int rightChild = (key << 1) + 2;
        int small = key;

        if (leftChild < size && arr[leftChild] < arr[small])
            small = leftChild;

        if (rightChild < size && arr[rightChild] < arr[small])
            small = rightChild;

        if (small != key) {
            swap(arr, small, key);
            reBuildHeap(arr, small, size);
        }
    }

    public static void swap(int[] arr, int index1, int index2) {

        arr[index1] = arr[index2] ^ arr[index1];
        arr[index2] = arr[index2] ^ arr[index1];
        arr[index1] = arr[index2] ^ arr[index1];
    }
}

时间复杂度 （N-k）*logN

测试

public static void main(String[] args) {

        for(int i=1;i<9;i++){
            int nums=(int)Math.pow(10,i);
            System.out.println("数据规模: "+nums);

            int[] test1=new int[nums];

            for(int j=0;j<test1.length;j++)
                test1[j]=(int)(Math.random()*test1.length);

            int[] test2= Arrays.copyOfRange(test1,0,test1.length);

            Long time1=System.currentTimeMillis();
            TopKBubble.topK(test1, 5);
            System.out.println("\n冒泡法用时 "+(System.currentTimeMillis()-time1)+"毫秒");

            time1=System.currentTimeMillis();
            TopKHeap.topK(test2, 5);
            System.out.println("小顶堆用时 "+(System.currentTimeMillis()-time1)+"毫秒");
            System.out.println("-------------------");
        }

    }

//output

//output

数据规模: 10

冒泡法用时 0毫秒
小顶堆用时 0毫秒
-------------------
数据规模: 100

冒泡法用时 0毫秒
小顶堆用时 0毫秒
-------------------
数据规模: 1000

冒泡法用时 0毫秒
小顶堆用时 0毫秒
-------------------
数据规模: 10000

冒泡法用时 0毫秒
小顶堆用时 0毫秒
-------------------
数据规模: 100000

冒泡法用时 15毫秒
小顶堆用时 16毫秒
-------------------
数据规模: 1000000

冒泡法用时 16毫秒
小顶堆用时 0毫秒
-------------------
数据规模: 10000000

冒泡法用时 141毫秒
小顶堆用时 31毫秒
-------------------
数据规模: 100000000

冒泡法用时 1355毫秒
小顶堆用时 83毫秒
-------------------

原理参照：传送门