剑指 Offer最小的k个数

题目描述

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]

排序

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        int[] vec = new int[k];
        Arrays.sort(arr);
        for (int i = 0; i < k; ++i) {
            vec[i] = arr[i];
        }
        return vec;
    }
}

优先队列

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        int[] vec = new int[k];
        if (k == 0) { // 排除 0 的情况
            return vec;
        }
        //构建大顶堆。从大到小进行排序
        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(arr[i]);
        }
        //队列头部是最大值
        for (int i = k; i < arr.length; ++i) {
            if (queue.peek() > arr[i]) {
                queue.poll();
                queue.offer(arr[i]);
            }
        }
        for (int i = 0; i < k; ++i) {
            vec[i] = queue.poll();
        }
        return vec;
    }
}

快排思想变形

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        quickSort(arr, 0, arr.length - 1, k - 1);
        int[] ans = new int[k];
        for (int i = 0; i < k; i++) {
            ans[i] = arr[i];
        }
        return ans;
    }

    public void quickSort(int[] array, int left, int right, int k) {
        if (left >= right) {
            return;
        }
        int i = partition(array, left, right);
        if (i == k) {
            return;
        }
        if (i > k) {
            quickSort(array, left, i - 1, k);
        } else {
            quickSort(array, i + 1, right, k);
        }

    }

    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];
            //从后往前找到第一个比key小的数与array[i]交换；
            //注意 = 号
            while (left < right && array[left] <= key) {
                left++;
            }
            array[right] = array[left];
            //从前往后找到第一个比key大的数与array[j]交换；
        }
        array[left] = key;
        return left;
    }
}

计数排序

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // 统计每个数字出现的次数
        int[] counter = new int[10001];
        for (int num: arr) {
            counter[num]++;
        }
        // 根据counter数组从头找出k个数作为返回结果
        int[] res = new int[k];
        int idx = 0;
        for (int num = 0; num < counter.length; num++) {
        	//重复元素
            while (counter[num]-- > 0 && idx < k) {
                res[idx++] = num;
            }
            if (idx == k) {
                break;
            }
        }
        return res;
    }
}

附，怎么找到数组的前k个元素

方法一，快速排序
方法二，自己构建大顶堆，或者利用优先队列。
方法三，快排变形
方法四，数据简单，范围较小，直接计数排序