昨天的topK的两种思路的伪代码实现

topK的伪代码如下(堆思想的实现)
print topK()
    int k //输入k个数
    int index = 0 用来计数输入了多少个元素
    int [] heap 数组大小
    
    k = scanner.nextInt（）
    x = scanner.nextInt()
    while (x!=-1)
      deal(x)
      x = scanner.nextInt（）  
    //当大小不足k的时候则添加元素，
     如果等于k则进行建堆，而后再与k+1
    个元素比较，如果小于不免，大于的话替换
    并进行向下调整成小顶堆
    private static void deal(int x)
        if (index<k)
            heap[index++] = x //当加满了立即堆化
            if (index ==k)
                //堆化
                makeMinHeap（heap）
        else {
            if (heap[0]<x)
                heap[0]=x;
                minHeapFixDown(heap,0,k);
                print heap
         }
            
堆化
makMinHeap(arr)
   n = (arr.length)/2-1
   for (int i=n;i<=0;i--) //从最后一个父亲节点处开始调整
      minHeapFixDown(arr,i,n)
minHeapFixDown(arr,i):
    left = 2*i+1
    right = 2*i+2
    
    min = 0
    //边界条件判断
    if(left>=n)
       return;
    min = left;
    if (right>=n)
       min = left
    else
       if (arr[right]<arr[left])
           min = right
    //如果arr[i]比两个孩子小，不用调整
      if(arr[i]<=arr[min])
         return;
    //否则，进行交换
    temp  = arr[i]
    arr[i] = arr[min]
    arr[min] = temp;
    minHeapFixDown(arr,min,n)                    

总结partition和堆都能解决顺序统计量问题，但是
堆更适用于海量数据流，parttition需要把所有数据
装入内存当中。

topK的另外实现构造数组大小k
void topK()
    k = scanner.nextInt（）
    x = scanner.nextInt()
    index = 0
    int [] heap 
    while (x!=-1)
      dealHeap(x)
      x = scanner.nextInt（）  
void dealArray（x）
    if (index<k)
      heap[index++]=x
      if (index==k)
          min = minArr(heap)
    else
       if x>A[min]
          A[min] =x
          min = minArr(heap)