TOP-K

输入n个整数，找出其中最小的K个数

package interview_offer_b;

import java.util.Arrays;

/** 
 * @author  作者 yyx E-mail: yyxyyxyang@126.com
 * @version 创建时间：2015-7-11 上午7:59:53 
 * 题目： 输入n个整数，找出其中最小的K个数。
 * 例如：
 * 输入：4，5，1，6，2，7，3，8
 * 输出：最小的4个数字是1，2，3，4。
 * 
 * 类似题目与分析：
 * 编程之美2.5_寻找最大的K个数
 * 可能存在的条件限制：
 * 要求 时间 和 空间消耗最小、海量数据、待排序的数据可能是浮点数等
 * 
 * 方法一：
 * 对所有元素进行排序，之后取出前K个元素，不提倡使用
 * 思路：使用最快排序算法，选择快排 或 堆排
 * 时间复杂度：O(n*logn) + O(K) = O(n*logn)
 * 特点：需要对全部元素进行排序，K = 1 时，时间复杂度也为O(n*logn)
 * 注意：题中只需得到最大的K个数，而不需要对后面N-K个数排序
 * 
 * 方法二：
 * 只需要对前K个元素排序，不需要对N-K个元素进行排序，不提倡使用
 * 思路：使用 选择排序 或 起泡排序，进行K次选择，可得到第k大的数
 * 时间复杂度：O(n*k)
 * 
 * 方法三：
 * 不对前K个数进行排序 + 不对N-k个数排序，可以使用
 * 思路：寻找第K个大元素。
 * 具体方法：使用类似快速排序，执行一次快速排序后，每次只选择一部分继续执行快速排序，直到找到第K个大元素为止，此时这个元素在数组位置后面的元素即所求
 * 
 * 在数组S中^^随机找出一个元素X，把数组分为两部分Sa和Sb。Sa中的元素大于等于X，Sb中元素小于X。  
 * 这时有两种情况：  
 *    1. Sa中元素的个数小于k，则Sb中的第k-|Sa|个元素即为第k大数；  
 *    2. Sa中元素的个数大于等于k，则返回Sa中的第k大数。  
 * 时间复杂度：
 *       若随机选取枢纽，线性期望时间O(N)
 *       若选取数组的“中位数的中位数”作为枢纽，最坏情况下的时间复杂度O(N)
 * 方法四：
 * 利用最大最小堆来求。
 * 首先建立K个最小堆(假设这K个数是连续最小的K个最大值)
 * 再取剩余的数逐个和最小堆的堆顶比较，如果取出的数比堆顶值还小，说明不够资格(因为求最大的K个值)，反之进堆，调整堆。直到取完所有数。
 * 时间复杂度：O(n*logK)
 */
public class FTopK {
    // 方法一
    public int[] topK(int[] a, int k){
        int len = a.length;
        if(len<1 || k<1||k>len)
            return null;
        Arrays.sort(a);
        int[] acopy = new int[k];
        System.arraycopy(a, 0, acopy, 0, k);
        return acopy;
    }
    // 方法二
    public int[] topK1(int[] a, int k){
        int len = a.length;
        if(len<1 || k<1||k>len)
            return null;
        for(int j=0;j<k;j++){//只适用于k远小于数组长度的情况
            int min = j;
            for(int i=j+1;i<len;i++){
                if(a[i]<a[min]){
                    min = i;
                }
            }
            swap(a,j,min);
        }
        int[] acopy = new int[k];
        System.arraycopy(a, 0, acopy, 0, k);
        return acopy;   
    }
    // 方法三
    public int[] topK2(int[] a, int k){//
        int len = a.length;
        if(len<1 || k<1||k>len)
            return null;
        int low = 0;
        int high = len-1;
        int pos = partition(a,low,high);
        int[] res = new int[k];
        if(k-1==pos){// 第K小的数是下标为K-1的数
            System.arraycopy(a, 0, res, 0, k);//复制前面的k个数
            return res;
        }

        while(k-1<pos){
            pos = partition(a,low,pos-1);       
        }
        while(k-1>pos){
            pos = partition(a,pos+1,high);  
        }
        // 跳出两个循环之后k-1==pos
        System.arraycopy(a, 0, res, 0, k);
        return res;
    }

    private int partition(int[] a, int low, int high){//分区
        int tmp = a[low];
        int i = low;
        int j = high;
        while(i<j){
            while(i<j && a[i]<=tmp)
                i++;
            while(a[j]>tmp)
                j--;
            if(i<j)
                swap(a,i,j);
        }
        swap(a,low,j);
        return j;
    }
    private void swap(int[] a, int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;

    }
    // 方法四
    public int[] topK3(int[] a, int k){
        int len = a.length;
        if(len<1 || k<1||k>len)
            return null;

        int[] heap = this.createHeap(a, k);

        for(int i=k;i<len;i++){
            if(a[i]<heap[0]){
                this.insert(heap, a[i]);
            }
        }
        return heap;
    }
    private void insert(int[] a, int v){//调整堆时间复杂度O(logn)
        a[0] = v;//把heap[0]，即a[0]覆盖掉
        int parent = 0;

        int lena = a.length;
        while(parent<lena){
            int lchild = 2*parent+1;
            int rchild = 2*parent+2;
            int maxIndex = parent;
            if(lchild<lena&&a[lchild]>a[parent])
                maxIndex = lchild;
            if(rchild<lena&&a[rchild]>a[maxIndex])
                maxIndex = rchild;
            if(maxIndex==parent)
                break;
            else{
                int tmp = a[parent];
                a[parent] = a[maxIndex];
                a[maxIndex] = tmp;
            }
        }
    }

    private int[] createHeap(int[] a, int k){//建堆时间复杂度O(n)
        int[] res = new int[k];
        for(int i=0;i<k;i++){
            res[i] = a[i];
        }
        for(int j=1;j<k;j++){
            int child = j;
            int parent = (j-1)/2;
            int tmp = res[j];
            while(parent>=0&&child!=0&&res[parent]<tmp){//最大堆
                res[child] = res[parent];
                child = parent;
                parent = (parent-1)/2;
            }
            res[child] = tmp;
        }
        return res;
    }
    private void printArray(int[] a){
        if(a==null)
            return;
        int len = a.length;
        for(int i=0;i<len;i++){
            System.out.print(a[i]);
            if(i!=len-1)
                System.out.print(",");
        }
    }
    public static void main(String[] args) {
        FTopK tk = new FTopK();
        System.out.println("------topK-----");
        int[] a = {4,5,1,6,2,7,3,8};
        System.out.println("before sort:");
        tk.printArray(a);
        int[] res = tk.topK(a,4);
        System.out.println("\nafter sort:");
        tk.printArray(res);

        System.out.println("\n-----topK1-----");
        int[] a1 = {4,5,1,6,2,7,3,8};
        System.out.println("before sort:");
        tk.printArray(a1);
        int[] res1 = tk.topK1(a1,4);
        System.out.println("\nafter sort:");
        tk.printArray(res1);

        System.out.println("\n-----topK2-----");
        int[] a2 = {5,5,1,6,9,7,3,12};
        System.out.println("before sort:");
        tk.printArray(a2);
        int[] res2 = tk.topK2(a2,4);
        System.out.println("\nafter sort:");
        tk.printArray(res2);

        System.out.println("\n-----topK3-----");
        int[] a3 = {5,5,1,6,9,7,3,12};
        System.out.println("before sort:");
        tk.printArray(a3);
        int[] res3 = tk.topK3(a3, 4);
        System.out.println("\nafter sort:");
        tk.printArray(res3);
    }

}