【数组】剑指Offer: 最小的K个数

【在线编程】最小的K个数

【问题描述】

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

【解题思路 & Java实现】

方法一：先排序，然后输出前k个数。时间复杂度 O(nlogn)

import java.util.*;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> result = new ArrayList<>();
        
        Arrays.sort(input);
        if(k <= input.length) {
            for(int i = 0; i < k; i++) {
                result.add(input[i]);
            }
        }
        
        return result;
    }
}

方法二：利用快速排序的 partition 函数，只要返回的 pivot 为k-1就可以了，input[k-1]左边的元素全部小于它。时间复杂度为 O(n).但是这种方法不是有序输出。
注意！！！当 k<= 0时，程序会进入死循环，一定要在程序最开始全面考虑边界情况和特殊情况！
同样思路：数组中出现次数超过一半的数字（方法二）

import java.util.*;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> result = new ArrayList<>();
        if(input==null || input.length==0 || k<=0 || k>input.length) {
            return result;
        }
        int left = 0;
        int right = input.length-1;
        int pivot = partition(input, left, right);
        
        while(pivot != k-1) {
            if(pivot < k-1) {
                pivot = partition(input, pivot+1, right);
            } else {
                pivot = partition(input, left, pivot-1);
            }
        }
        
        for(int i=0; i<k; i++) {
            result.add(input[i]);
        }
        return result;
    }
    
    public int partition(int[] array, int left, int right) {
        int key = array[left];
        
        while(left < right) {
            while(left < right && array[right] >= key) {
                right--;
            }
            array[left] = array[right];
            
            while(left < right && array[left] <= key) {
                left++;
            }
            array[right] = array[left];
        }
        array[left] = key;
        return left;
    }
}

方法三：利用 PriorityQueue. PriorityQueue 是基于堆结构实现的优先队列。默认是小根堆。时间复杂度 O(nlogk).

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.PriorityQueue;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
        ArrayList<Integer> result = new ArrayList<>();

        if(input==null || input.length==0 || k > input.length || k <= 0){
            return result;
        }

        // 构建一个大小为 k 的大根堆
        PriorityQueue<Integer> maxHeap = new java.util.PriorityQueue<>(k, new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });

        for (int i = 0; i < input.length; i++) {
            if (maxHeap.size() != k) {
                maxHeap.offer(input[i]);
            } else if (maxHeap.peek() > input[i]) {
                maxHeap.poll();
                maxHeap.offer(input[i]);
            }
        }
        while (!maxHeap.isEmpty()) {
            result.add(maxHeap.poll());
        }

        //如果需要按从小到大顺序输出的话。时间复杂度O(n)
        Collections.reverse(result);

        return result;
    }
}