《剑指Offer》Java刷题 NO.29 最小的K个数（数组、partation、最大堆最小堆）

《剑指Offer》Java刷题 NO.29 最小的K个数（数组、partation、最大堆最小堆）

传送门：《剑指Offer刷题总目录》

时间：2020-05-07
题目： 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

---

思路：
法一： Partation算法 ，同上一题的思想，平均O(n)
只不过不是找中位数了，而是找第k个数，其左边都比它小，右边都比它大，具体思路见上一题（NO.28）
缺点： 会改变输入数组的元素位置
法二： 利用最大堆/最小堆
java的优先级队列PriorityQueue底层是用数组实现的堆，可以自定义comparator根据存放对象的特点构造依据不同的优先级顺序
此题的最大堆思路：先取出k个数构建最大堆【O(k)】，然后剩下的n-k个数，如果比当前的堆顶小，就把堆顶换下来然后下滤【O(logn)】,最坏情况下，n-k个数都要进行交换，总的时间复杂度为O(k)+O(（n-k）logn)既O(nlogn),空间复杂度为O(k)
最小堆思路：用数组所有元素构建最小堆【O(n)】，然后poll出栈顶k次，然后调整堆【O(logn)】，总的时间复杂度是O(n+klogn),空间复杂度是O(n);当数据规模较大时，最小堆可能会内存溢出

---

Java代码：

import java.util.*;
import java.util.stream.Collector;

/**
 * @ClassName GetLeastNumbers
 * @Discription 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，
 * 则最小的4个数字是1,2,3,4。
 * @Author lemon
 * @Date 2020/5/7 12:39
 **/
public class GetLeastNumbers {
    /**
     * partation算法：找到坐标为k-1的pivot
     */
    public ArrayList<Integer> getLeastNumbersOne(int[] input, int k) {
        ArrayList<Integer> result = new ArrayList<>(k);
        //处理非法和特殊输入
        if (input.length <= 0 || k > input.length || k <= 0) {
            return result;
        }
        if (input.length == k) {
            for (int i = 0; i < k; i++) {
                result.add(input[i]);
            }
            return result;
        }
        int start = 0;
        int end = input.length - 1;
        int index = partation(input, start, end);
        while (index != (k - 1)) {
            if (index > (k - 1)) {
                end = index - 1;
                index = partation(input, start, end);
            } else {
                start = index + 1;
                index = partation(input, start, end);
            }
        }
        for (int i = 0; i < k; i++) {
            result.add(input[i]);
        }
        return result;
    }

    public int partation(int[] arr, int start, int end) {
        int pivotIndex = (int) (start + Math.random() * (end - start + 1));
        //将pivot藏在最后
        swap(arr, pivotIndex, end);
        int pivot = arr[end];
        int left = start - 1;
        int right = end;
        while (true) {
            while (left < right && arr[++left] < pivot) {
            }
            while (left < right && arr[--right] > pivot) {
            }
            if (left < right) {
                swap(arr, left, right);
            } else {
                break;
            }
        }
        swap(arr, right, end);
        return right;
    }

    private void swap(int[] arr, int a, int b) {
        int temp;
        temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    /**
     * 利用最大堆，先取出k个数构建最大堆，然后剩下的n-k个数，如果比当前的堆顶小，
     * 就把堆顶换下来然后下滤
     */
    public ArrayList<Integer> getLeastNumbersTwo(int[] input, int k) {
        ArrayList<Integer> result = new ArrayList<>(k);
        if (input.length <= 0 || k <= 0 || k > input.length) {
            return result;
        }
        /*用匿名内部类构造comparator，优先级队列默认堆顶（队头）是最小值，所以要自己定义一下，反过来
        系统提示我用lamda表达式，但是ac出来时上百ms，比较慢，经查证，数据量比较大时，lamda表达式
        才和普通方式差距不大*/
        //PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k,(m,n) -> (n - m));
        PriorityQueue<Integer> maxHeap = new 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 (input[i] < maxHeap.peek()) {
                Integer temp = maxHeap.poll();
                //垃圾回收
                temp = null;
                maxHeap.offer(input[i]);
            }
        }
        for (Integer integer : maxHeap) {
            result.add(integer);
        }
        return result;
    }

    /**
     * 利用最小堆，用数组所有元素构建最小堆，然后poll出栈顶k次，然后调整堆;
     * 当数据规模较大时，可能会内存溢出
     */
    public ArrayList<Integer> getLeastNumbersThree(int[] input, int k) {
        ArrayList<Integer> result = new ArrayList<>(k);
        if (input.length <= 0 || k <= 0 || k > input.length) {
            return result;
        }
        //PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k,(m,n) -> (n - m));
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k);
        for (int i = 0; i < input.length; i++) {
                maxHeap.offer(input[i]);
            }
        for (int i = 0;i < k;i++) {
            result.add(maxHeap.poll());
        }
        return result;
    }
    
}