java top k_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[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毫秒

-------------------

原理参照：传送门