找到无序数组中最小的k个数

题目：给定一个无序整数数组arr,找到其中最小的k个数

要求:如果数组arr的长度为n，排序之后自然可以得到最小的k个数，此时时间复杂度与排序的时间复杂度相同均为O（NlogN）,本题要求实现时间复杂度为O(NLogK).

1.O(NLogK)的方法，即一直维护一个有k个数的最大的大根堆，这个堆是目前选出的k个最小数，在堆里的k个元素中堆顶的元素是最大的一个。

接下来遍历整个数组，遍历的过程中看当前数是否比堆顶元素小。如果是，就把堆顶的元素替换成当前的数，然后从堆顶的位置调整堆，替换后堆的最大元素的位置依旧在堆顶；如果不是，则不进行任何操作，继续遍历下一个数；遍历完成后，堆中的k个数就是所有数组中最小的k个数。

具体请参看如下代码中的getMinKNumsByHeap方法，代码中的heapInsert和heapify方法分别为堆排序中的建堆和调整堆的实现。

public int[]  getMinKNumsByHeap(int[] arr,int k)
{
    if(k<1 || k>arr.length)
            return arr;
    int[] kHeap=new int[k];
    for(int i=0;i<k;i++)
    {
        heapInsert(kHeap,arr[i],i);
     }
   for(int i=k;i<arr.length;i++)
  {
       if(arr[i]<kHeap[0])
     {
          kHeap[0]=arr[i];
         heapify(kHeap,0,k);
     }
   }
  return kHeap;
}

public void heapInsert(int[] arr,int value,int index)
{
   arr[index]=value;
   while(index!=0)
  {
    int parent=(index-1)/2;
    if(arr[parent]<arr[index])
    {
       swap(arr,parent,index);
       index=parent;
    }
  else
     break;
  }
}

public void  heapify(int[] arr,int index,int heapSize)
{
    int left=index*2+1;
    int right=index*2+2;
    int largest=index;
   while(left<heapSize)
 {
     if(arr[left]>arr[index])
             largest=left;
     if(right<heapSize&&arr[right]>arr[largest])
              largest=right;
     if(largest!=index)
              swap(arr,largest,index);
      else
        break;
    index=largest;
    left=index*2+1;
    right=index*2+2;
    }
}

public void swap(int[] arr,int index1,int index2)
{
    int tmp=arr[index1];
    arr[index1]=arr[index2];
    arr[index2]=tmp;
}