《剑指offer》java实现 输入n个数，找到其中最小的K个数

思路一：借助快排中的partition思想，需要改动输入数组，时间复杂度O(n)

public class MinK {

 public static void main(String[] args) {
  int a[]={4,5,1,6,2,7,3,8};
  int k=5;
  int b[]=getmink(a, k);
  for(int i=0;i<b.length;i++){
   System.out.print(b[i]+" ");
  }
  //System.out.println(partition2(a, 0, a.length-1));

 }
 
 public static int[] getmink(int a[],int k){
  int n=a.length;
  int b[]=new int[k];
  for(int i=0;i<k;i++){
   b[i]=0;
  }
  if(n>=k){  
      int start=0;
   int end=n-1;
   int pos=partition2(a, 0, n-1);
   print(a);
   while(pos!=k-1){
    if(pos>k-1){
     end=pos-1;
     pos=partition2(a, start, end);
     print(a);
    }else{
     start=pos+1;
     pos=partition2(a, start, end);
     print(a);
    }
   }
   for(int i=0;i<k;i++){
    b[i]=a[i];
   }
  }
  return b;
 }
 
 public static void exch(int a[],int i,int j){
  int temp=a[i];
  a[i]=a[j];
  a[j]=temp;
 }
 
public static int partition2(int a[],int start,int end){
  int i=start;
  int j=end+1;
  int basevalue=a[start];
  while(true){
   while(a[++i]<basevalue){
    if(i==end){
     break;
    }
   }
   while(a[--j]>basevalue){
    if(j==start){
     break;
    }
   }
   if(i>=j){
    break;
   }
   exch(a, i, j);
  }
  exch(a, start, j);
  System.out.println(j);
  return j;
 }

}

思路二：借助最大堆的思想，不改动输入数据，适用于海量数据，时间复杂度O(nlogk)

public class GetLeastKNumber1 {

 public static void main(String[] args) {
  int[] a={3,6,1,4,9,8,12,10};
  prin(a);
  heapsort(a);
  prin(a);
  int k=6;
  int knum[]=getleastknumber(a, k);
  prin(knum);
 }
 
 public static void prin(int[] a){
  for(int i=0;i<a.length-1;i++){
   System.out.print(a[i]+" ");
  }
  System.out.print(a[a.length-1]+"\n");
 }
 
 public static void maxheap(int [] data,int parent,int heapsize){
  int left=parent*2;
  int right=parent*2+1;
  int large=parent;
  if((left<=heapsize)&&(data[left-1]>data[parent-1])){
   large=left;
  }
  if((right<=heapsize)&&(data[right-1]>data[large-1])){
   large=right;
  }
  if(large!=parent){
   int temp=data[parent-1];
   data[parent-1]=data[large-1];
   data[large-1]=temp;
   maxheap(data, large, heapsize);
  }
 }
 
 public static void buildmaxheap(int [] data){
  for(int i=data.length/2;i>0;i--){
   maxheap(data, i, data.length);
  }
 }
 
 public static void heapsort(int data[]){
  buildmaxheap(data);
  for(int i=data.length;i>1;i--){
   int temp=data[0];
   data[0]=data[i-1];
   data[i-1]=temp;
   maxheap(data, 1, i-1);
  }
 }
 
 public static int[] getleastknumber(int data[],int k){
  int knum[]=new int[k];
  if(data==null||k<1||data.length<k){
   return null;
  }
  for(int i=0;i<k;i++){
   knum[i]=data[i];
  }
  buildmaxheap(knum);
  for(int i=k;i<data.length;i++){
   if(data[i]<knum[0]){
    knum[0]=knum[k-1];
    maxheap(knum, 1, k-1);
    knum[k-1]=data[i];
    maxheap(knum, 1, k);
   }
  }
  return knum;
 }

}