java 查找最小的k个元素_java-5.查找最小的K个元素-使用最大堆

import java.util.Arrays;

import java.util.Random;

public class MinKElement {

/**

* 5.最小的K个元素

* I would like to use MaxHeap.

* using QuickSort is also OK

*/

public static void main(String[] args) {

MinKElement mke=new MinKElement();

int[] a={1,2,3,4,5,6,7,8};

int k=4;

mke.disArrange(a);

System.out.println("after disarranging,the array a[]="+Arrays.toString(a));

mke.findKMin(a,k);

}

//rearrange the array.just for test. 随机的调换数组

public void disArrange(int[] a){

for(int i=0,len=a.length;i

Random random=new Random();

int j=random.nextInt(len);

swap(a,i,j);

}

}

public void findKMin(int[] a,int k){

int[] heap=a;//you can do this:int[] heap=new int[k].but that maybe space-cost

//create MaxHeap of K elements.from the lastRootIndex to 0. 先建立K的最大堆，K个值，那么起始点为K/2-1

int rootIndex=k/2-1;

while(rootIndex>=0){

reheap(heap,rootIndex,k-1);

rootIndex--;

}

for(int i=k,len=heap.length;i

if(heap[i]

heap[0]=heap[i];

reheap(heap,0,k-1);

}

}

System.out.print("the K min elements=");

for(int i=0;i

System.out.print(heap[i]+",");

}

}

//reheap:from root to lastIndex.

public void reheap(int[] heap,int rootIndex,int lastIndex){

int orphan=heap[rootIndex];

boolean done=false;

int leftIndex=rootIndex*2+1;

while(!done&&leftIndex<=lastIndex){

int largerIndex=leftIndex;

if(leftIndex+1<=lastIndex){

int rightIndex=leftIndex+1;

if(heap[rightIndex]>heap[leftIndex]){

largerIndex=rightIndex;

}

}

//Attention! should not use -->heap[root]

//I spend time to find the problem....

if(orphan

heap[rootIndex]=heap[largerIndex];

rootIndex=largerIndex;

leftIndex=rootIndex*2+1;

}else{

done=true;

}

}

heap[rootIndex]=orphan;

}

public void swap(int[] a,int i,int j){

int temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}