题目·

输入整数数组 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]

限制：

0 <= k <= arr.length <= 10000 0 <= arr[i] <= 10000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

库函数排序

Java

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;}
}

C++

class Solution {
public:vector<int> getLeastNumbers(vector<int>& arr, int k) {vector<int> vec(k, 0);sort(arr.begin(), arr.end());for (int i = 0; i < k; ++i) {vec[i] = arr[i];}return vec;}
};

快速排序解法

什么是快排

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

• (1) 首先设定一个分界值，通过该分界值将数组分成左右两部分。

• (2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。

• (3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

• (4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

快排图解

首先设定一个分界值

以基准元素划分为左右两部分

递归处理左半部分和右半部分

递归图解

递归文字讲解

递归三步曲：

• 确定递归的入参

• 确定递归的终止条件

• 确定递推工作并重新进去递归

确定递归的入参

public static void sort(int [] arr, int k, int i, int j)

• k是基准元素下标

• i 是左边界

• j 是右边界

确定递归的终止条件

从上述中分析可知，递归的终止条件是i必须小于j。

if ( i >= j) return;

确定递推工作并重新进去递归

我们的递推工作主要是之前的以基准元素划分为左右两部分 每一次递归都需要这样进行去递推。根据前面的思路：

    // k是数组下标 i 是数组的左节点 j 是数组的右节点public static void sort(int [] arr, int k, int i, int j) {if ( i >= j) return;int low = i; // 保存此数组的左边界int high = j; // 保存此数组的右边界i = k + 1;// i指向了k i从下一个元素开始while( i < j) {while (i < j && arr[j] >= arr[k] ) {j--; // 右侧元素大于基准 }// 上述循环结束，说明此时j的元素小于基准while (i < j && arr[i] <= arr[k]) {i++;// 左侧元素小于基准 }// 上述循环结束，说明此时i的元素大于基准swap(arr, i, j);// 此时把i 和 j 交换 结果就是大于基准的都在右边小于基准的都在左边// 继续重复上述过程 直到i == j 循环结束 说明已经按基准分开}
}public static void swap(int [] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}

上述是一次递归的过程

上述处理完成的结果是这个样子的：

接下来是进入递归：

进入左半边数组递归处理：

递归函数就是调用自己：sort(int [] arr, int k, int i, int j)  // k是数组下标 i 是数组的左节点 j 是数组的右节点

我们需要确定左半边数组的sort函数的每个参数是什么：

• arr还是arr

• k是什么：low 和 high 是数组的左右边界，看图,我们来对号入座即可，新的基准是数组的左边界，也就是low

• i是什么，也代表新数组的左边界，也还是low

• j是什么：j代表左半边数组的右边界，看图知i-1即可 所以进入到左半边数组是：

sort(arr, low, low, i-1); // 处理基准元素左侧

同理确定如何递归处理数组的右半边：

sort(arr, i+1 , i + 1,high); // 处理基准元素右侧

合并一下：

package com.company;public class Main {public static void main(String[] args) {// write your code hereint [] arr  = {1 ,2 ,3 ,0, 1, 5, 4};sort(arr, 0 , 0 , arr.length - 1);for(int i = 0;i < arr.length;i++) {System.out.print(arr[i]);}}// k是数组下标 i 是数组的左节点 j 是数组的右节点public static void sort(int [] arr, int k, int i, int j) {if ( i >= j) return;int low = i;int high = j;i = k + 1;// i指向了k i从下一个元素开始while( i < j) {while (i < j && arr[j] >= arr[k] ) {j--; // 右侧元素大于基准}// 上述循环结束，说明此时j的元素小于基准while (i < j && arr[i] <= arr[k]) {i++;// 左侧元素小于基准}// 上述循环结束，说明此时i的元素大于基准swap(arr, i, j);// 此时把i 和 j 交换 结果就是大于基准的都在右边小于基准的都在左边// 继续重复上述过程 直到i == j 循环结束 说明已经按基准分开}swap(arr, i, k); // 交换基准数 和 i 的位置。sort(arr, low, low, i-1); // 处理基准元素左侧sort(arr, i+1 , i + 1,high); // 处理基准元素右侧}public static void swap(int [] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
}

快排动画

我们的目的是寻找最小的 k 个数。假设经过一次 partition 操作，基准元素位于下标 m，也就是说，左侧的数组有 m 个元素，是原数组中最小的 m 个数。那么：

• 若 k = m，我们就找到了最小的 k 个数，就是左侧的数组；

• 若 k<m，则最小的 k 个数一定都在左侧数组中，我们只需要对左侧数组递归地 parition 即可；

• 若 k>m，则左侧数组中的 m 个数都属于最小的 k 个数，我们只需要对右侧数组递归地 parition 即可；

• 也就是说，不必每次只会递归左半边数组或者右半边数组，不会全部左半边和右半边都去递归。

• 具体代码区别就是在递归那里加一个判断，

代码·

Java

class Solution {public int[] getLeastNumbers(int[] arr, int k) {if (k >= arr.length) return arr;int AnotherK = k;return quickSort(arr,  k, 0, arr.length - 1);}public int [] quickSort(int [] arr,int k ,int i, int j) {int low = i;int high = j;// 一次处理while(i < j) {while (i < j && arr[j] >= arr[low]) {j--;}while( i < j && arr[i] <= arr[low]) {i++;}swap(arr, i, j);}swap(arr, low, i);// 一次处理结束 需要进行判断当前i和k之间的关系if (i == k) {return Arrays.copyOf(arr, k);}if (i > k) {quickSort(arr, k,low,i-1);} else {quickSort(arr,k,i+1,high);}return Arrays.copyOf(arr, k);}public  void swap(int [] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
}

C++

class Solution {
public:vector<int> getLeastNumbers(vector<int>& arr, int k) {if (k >= arr.size()) return arr;return quickSort(arr, k, 0, arr.size() - 1);}
private:vector<int> quickSort(vector<int>& arr, int k, int l, int r) {int i = l, j = r;while (i < j) {while (i < j && arr[j] >= arr[l]) j--;while (i < j && arr[i] <= arr[l]) i++;swap(arr[i], arr[j]);}swap(arr[i], arr[l]);if (i > k) return quickSort(arr, k, l, i - 1);if (i < k) return quickSort(arr, k, i + 1, r);vector<int> res;res.assign(arr.begin(), arr.begin() + k);return res;}
};

JS

/**** @param {number[]} arr* @param {number} start* @param {number} end* @return {number}*/
function partition(arr, start, end) {const k = arr[start];let left = start + 1,right = end;while (1) {while (left <= end && arr[left] <= k) ++left;while (right >= start + 1 && arr[right] >= k) --right;if (left >= right) {break;}[arr[left], arr[right]] = [arr[right], arr[left]];++left;--right;}[arr[right], arr[start]] = [arr[start], arr[right]];return right;
}/*** @param {number[]} arr* @param {number} k* @return {number[]}*/
var getLeastNumbers = function(arr, k) {const length = arr.length;if (k >= length) return arr;let left = 0,right = length - 1;let index = partition(arr, left, right);while (index !== k) {if (index < k) {left = index + 1;index = partition(arr, left, right);} else if (index > k) {right = index - 1;index = partition(arr, left, right);}}return arr.slice(0, k);
};

Python

class Solution(object):def getLeastNumbers(self, arr, k):""":type arr: List[int]:type k: int:rtype: List[int]"""# 方法一:partition方法(基于快速排序)if k > len(arr) or k <= 0:return [] start = 0end = len(arr) - 1index = self.quickSort(arr, start, end)while index != k-1:print(index)if index > k-1:end = index - 1index = self.quickSort(arr, start, end)if index < k-1:start = index + 1index = self.quickSort(arr, start, end)return arr[:k]def quickSort(self, arr, start, end):low = starthigh = endtemp = arr[start]while low < high:while low < high and arr[high] >= temp:high -= 1arr[low] = arr[high]while low <high and arr[low] < temp:low += 1arr[high] = arr[low]arr[low] = tempreturn low