剑指offer 29.最小的K个数

 29.最小的K个数

题目描述

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

思路一：

1.. 建立最大堆，对数组前 k 个元素建立最大堆，对 k 后面的每个元素，与堆顶元素进行大小比较，如果小于堆顶元素，则用当前元素替换为堆顶元素，并进行一次向下过滤，如果不小于堆顶元素，则直接跳过。

始终保证堆中的元素是小的 k 个

import java.util.ArrayList;
public class Solution {
    
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {

        // 建立最大堆
        ArrayList<Integer> list = new ArrayList<Integer>(k);

        if (input == null || input.length < k) {
            return list;
        }
        // 建堆
        int n = k;
        for (int i = (n / 2 - 1); i >= 0; i--) {
            downAdj(input, i, n);
        }


        // 每当读入一个元素，与堆顶元素比较大小，
        for (int i = k; i < input.length; i++) {
            // 如果小于大堆顶元素，则用当前数替换堆顶元素，进行一次向下过滤
            // 如果小于的话，直接丢弃这个数
            if (input[i] < input[0]) {
                input[0] = input[i];
                downAdj(input, 0, n);
            }

        }

        // 最后对这个堆进行堆排序，输出
        for (int i = n - 1; i >= 0; i--) {
            int temp = input[0];
            input[0] = input[i];
            input[i] = temp;
            downAdj(input, 0, i);
        }

        // 把 k 个数放到集合中
        for(int i = 0; i < n; i++){
            list.add(input[i]);
        }
        return list;
    }

    // 向下过滤
    public void downAdj(int[] A, int p, int n) {
        int parent, child = p;
        int x = A[p];
        for (parent = p; 2 * parent < n; parent = child) {
            child = 2 * parent;
            if (child + 1 < n && A[child + 1] > A[child]) {
                child++;
            }
            // 与最大的孩子结点比较，如果父节点大，说明找到了位置，
            if (x >= A[child]) {
                break;
            }
            // 否则让最大的孩子上位
            else {
                A[parent] = A[child];
            }

        }
        A[parent] = x;
    }
}

使用PriorityQueue代替手动建堆过程

class Solution {
    // 使用最小堆，每次从堆中取一个元素
    public int[] getLeastNumbers(int[] arr, int k) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>(K+1);
        int[] res = new int[k];
        int len = arr.length;
        for(int i = 0; i < len; i++){
            minHeap.offer(arr[i]);
        }
        for(int i = 0; i < k; i++){
            res[i] = minHeap.poll();
        }
        return res;
    }
}

leetcode运行时间为19ms, 空间为39.8MB

复杂度分析：

时间复杂度：建堆过程花费的时间为O(nlog(k+1)), 取前k 个元素花费的时间为O(klogk)

空间复杂度：堆的大小即为空间复杂度，所以空间复杂度为O(k+1)

思路二: 快速排序

利用快速排序，经过若干轮轮快排后，如果主元位置刚好为k-1, 那么前半段元素即使数组中最小的k个元素

class Solution {
    // 利用快速排序的过程，经过若干轮轮快排后，如果主元位置刚好为k-1, 那么前半段元素即使数组中最小的k个元素
    public int[] getLeastNumbers(int[] arr, int k) {

       // arr进行若干轮快排
       quickSort(arr, 0, arr.length-1, k);

       // 返回前k个元素的范围数组 
       return Arrays.copyOfRange(arr, 0, k);
    }

    // 快排
    public void quickSort(int[] arr, int left, int right, int k){
        // 如果left < right继续快排
        if(left < right){
            // 对[left, right]区间的元素进行一轮快排，获取到快排后的主元位置
            int pivotIndex = partition(arr, left, right);
            if(pivotIndex == k-1){
                return;             // 如果主元位置刚好是k-1, 直接返回
            }
            // 否则，继续递归快排左右子区间
            quickSort(arr, left, pivotIndex - 1, k);
            quickSort(arr, pivotIndex + 1, right, k);
        }
    }

    // 一次快排操作
    public int partition(int[] arr, int left, int right){
        // 选定第一个元素作为主元
        int pivot = arr[left];
        // 当left < right时一直循环
        while(left < right){
            while(left < right && arr[right] >= pivot){
                right--;
            }
            arr[left] = arr[right];
            while(left < right && arr[left] <= pivot){
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = pivot;
        return left;
    }
}

leetcode运行时间为9ms, 空间为40.3MB,可以看到比思路一快很多

复杂度分析：

时间复杂度：若干次快排，复杂度为O(n), 具体不会证明，参考：具体证明可以参考《算法导论》第 9 章第 2 小节。

空间复杂度：递归栈的深度最小为O(logn), 最大为O(n)