排序-最小的K个数-JZ29

描述
给定一个数组，找出其中最小的K个数。例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
0 <= k <= input.length <= 10000
0 <= input[i] <= 10000

示例1

输入：
[4,5,1,6,2,7,3,8],4
返回值：
[1,2,3,4]
说明：返回最小的4个数即可，返回[1,3,2,4]也可以

思路1：
堆排序，可以维持一个大小为k的大顶堆，若是后面有比大顶堆堆顶数据小的数，则可以放入，且将原来的堆顶数据拿出，堆排序只要维持堆的顺序，减少了所需时间。
时间复杂度：O(nlogk), 插入容量为k的大根堆时间复杂度为O(logk), 一共遍历n个元素
空间复杂度：O(k)

代码：

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

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList<>();
        //检验参数
        if(k <= 0 || k > input.length) {
            return res;
        }
        // 设置大顶堆存放数据
        PriorityQueue<Integer> queue = new PriorityQueue<Integer>(new Comparator<Integer>() {
            public int compare(Integer num1, Integer num2) {
                return num2 - num1;
            }
        });
        for (int i = 0; i < k; ++i) {
            queue.offer(input[i]);
        }
        for (int i = k; i < input.length; ++i) {
            if (queue.peek() > input[i]) {
                queue.poll();
                queue.offer(input[i]);
            }
        }
        for (int i = 0; i < k; ++i) {
            res.add(queue.poll());
        }
        return res;
    }
}  

思路2：
快速排序思想，与一般的快速排序相比，只用操作数组的一半（大于或小于情况中的一种，有判断）

时间复杂度：O(n)，对于长度为 n 的数组执行哨兵划分操作的时间复杂度为 O(n) ；每轮哨兵划分后根据 k 和 i 的大小关系选择递归，由于 i 分布的随机性，则向下递归子数组的平均长度为 n/2 ；因此平均情况下，哨兵划分操作一共有 n + n/2 + n/4 + … + n/n = n + (n-1)/n < 2n ，总体时间复杂度为 O(n)。
空间复杂度：O(logn)，划分函数的平均递归深度为O(logn)。

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList<>();
        //检验参数
        if(k <= 0 || k > input.length) {
            return res;
        }
       // 快排  k == input.length时跳过排序
        if (k < input.length) {
            quickSort(input, k, 0, input.length-1);    
        }
        //获取数组前k个数 
        for (int i = 0; i < k; ++i) {
            res.add(input[i]);
        }
        return res;
    }
    private void quickSort(int[] input, int k, int left, int right) {
        int i = left;
        int j = right;
        while (i < j) {
        	//必须先把--j的循环放前面 ++i的循环放后面，不然循环外第二个swap变更基准数字位置的时候会出错  
        	// 可以用[4,3,1,6,2,7,3,8],4 样例 测试一下就知道了
            while(i < j && input[j] >= input[left]) {
                --j;
            }
            while(i < j && input[i] <= input[left]) {
                ++i;
            }
            swap(input, i, j);
        }
        //一次遍历后变更基准数字的位置
        swap(input, i, left);
        // 若i大于k，则要往前找
        if (i > k) {
            quickSort(input, k, left, i-1);
        }
        if (i < k) {
            quickSort(input, k, i+1, right);
        }
    }
    private void swap(int [] input, int i, int j) {
        int temp = input[i];
        input[i] = input[j];
        input[j] = temp;
    }
}