面试：数组：Topk _1

题目

求一维数组中最小的k个数字

---

快排算法

复杂度：O(klgn)

import java.util.*;

class Solution{
     //选择一个数，将数组分为大小两个部分
    public int partition(int data[],int start,int end){
        int pivotvalue=data[start];

        while(start<end){
            while(start<end && data[end]>=pivotvalue)
                --end;

            // 将比pviot小的元素移动到低端，此时right空，等待低位比pviotvalue大的数补上
            data[start]=data[end];

            while(start<end && data[start]<=pivotvalue)
                ++start;

            //此时比pviot大的元素移动到了高端，此时left位相当于空，等待高位比pivotalue小的数补上
            data[start]=data[end];
        }

        //当start=end，完成一次快速排序，此时left相当于空，等待pivotvalue补上
        data[start] = pivotvalue;

        return start;

    }

    // 若返回的小标是k-1，则结束；否则，调用partition到下标为k-1

    public void getTopk(int[] data,int k){
        int start = 0,end = data.length-1;
        int index=partition(data,start,end);
        while(index!=k-1){
            if(index>k-1){
                // 从index前面重新查找
                 end = index-1;
                 index = partition(data,start,end);
            }else{
                start=end-1;
                index=partition(data,start,end);
            }
        }

        for(int i=0;i<k;i++)
            System.out.println(data[i]+"\t");

    }

}

---

堆排序算法

复杂度：O (nlgK)

算法;
1. 创建小根堆，初始化大小为k，堆顶为堆得最大元素
2. 扫描数组，往最小堆插入数据，如果堆得元素个数达到k，那么新元素需要和堆顶元素比较，如果小于堆顶，插入新元素。
3. 最终得到k个最小元素。

---

import java.util.*;

class MinHeap{
    // 堆存储数组
    private int[] data;

    // 构建小根堆
    public  MinHeap(int[] data){
        this.data=data;
        bulidHeap();
    }

    // 数组转换为小根堆
    private void bulidHeap(){
        for(int i=(data.length)/2-1;i>=0;i--)
            heapify(i); // 对孩子节点调用heapify
    } 

    //简化写法
    private void heapify(int k){
        int N=data.length;
        while(2*k<=N){
            int j=2*k;
            if(j<N && less(j,j+1))
                j++;
            if(!less(k,j))
                break;
            exch(k,j);
            k=j;
        }
    }

    /*
    // 好理解的写法
    private void heapify(int k){
        // 获取左右节点的数组的下标
        int l=left(i);
        int r =right(i);

        // 临时变量
         int smallest=i;

         //若存在左节点，且左节点的值下于根节点
          if(l<data.length && data[l]<data[i])
             smalleat=l;

         if(r<data.length && data[r]<data[smalleat])
            smalleat=r;
          // 左右节点都大于根节点直接return
           if(i==smallest)
             return;
          //交换节点
           swap(i,smalleat);

           // 交替后左右子树有影响，对收影响的子树再次heapify
            heapify(smalleat);

    }

    */


    private boolean less(int i,int j)
    {
        if(data[i]<data[j])
            return true;
        else
            return false;
    }

    private void exch(int i, int j)
    {
        int key=data[i];
        data[i]=data[j];
        data[j]=key;

    }

    public int getRoot(){
        return data[0];
    }

    // 替换根节点，并重新heapify

    public void setRoot(int root)
    {
        data[0]=root;
        heapify(0);
    }
}

public class Solution{
    public static void main(String[] args){
        // 元数据
        int[] data={56,275,12,6,45,478,41,1236,456,12,546,45};

        //top5
         int[] top5=topk(data,5);
         for(int i=0;i<5;i++)
             System.out.println(top5[i]);
    } 

    private static int[] topk(int[] data,int k){
        //取得k个元素放入一个数组topk中
        int[] topk=new int [k];
        for(int i=0;i<k;i++)
            topk[i]=data[i];

        // 转换为小根堆
        MinHeap heap =new MinHeap(topk);

        for(int i=k;i<data.length;i++){
            int root = heap.getRoot();

            //根据大于堆中最小的数 ，替换堆中的根节点，再转换为堆

            if(data[i]>root)
                heap.setRoot(data[i]);
        }
        return topk;

        }
    }