题目描述

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

示例

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

算法思路

思路一

直接对数组进行排序，然后取前 k 个数字

思路二

采用优先队列，使用 java 中的 PriorityQueue 这个api，它默认是最小堆。把数组中的数字全部添加到优先队列中，然后取出优先队列的前 k 个数。

思路三

使用快速排序的特点。先看一遍快速排序的基本框架。（其实快速排序就是树的前序遍历，不知道各位看出来了没）

//left = 0,right = a.length-1;
void QuickSort(int a[],int left,int right){
    
    //递归结束条件
    if(right<=left){
        return;
    }
    int mid = partition(a,left,right);
    QuickSort(a,left,mid-1);
    QuickSort(a,mid+1,right);
    
}

int partition(int a[],int left,int right){
    //定义左右扫描指针
    int i = left;
    int j = right+1;
    int x = a[left];//以第一个为基准元素
    //将大于等于x的元素交换到右边区域
    //将小于等于x的元素交换到左边区域
    while(true){
        while(a[++i]<x) if(i==right) break;
        while(a[--j]>x);
        if(i>=j) break;
        swap(a,i,j);      
    }
    swap(a,left,j);//a[left]是基准元素
    return j;
}

关键就是这个 mid ，这个 mid 就相当于二分法的 mid

当 mid=k 时，直接返回数组的前 k 个
当 mid<k 时，表示 k 在右边的递归中
当 mid>k时，表示 k 在左边的递归中

代码实现

实现一

import java.util.*;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        Arrays.sort(input);//对数组排序
        ArrayList<Integer> res = new ArrayList<>();
        for(int i=0;i<k;i++){
            res.add(input[i]);
        }
        return res;
    }
}

实现二

import java.util.*;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
    	//优先队列
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        //把数组中的数字添加到优先队列中
        for(int i:input){
            queue.offer(i);
        }
        //取出优先队列中的前 k 个数字
        int j=0;
        ArrayList<Integer> res = new ArrayList<>();
        while(j++<k){
            res.add(queue.poll());
        }
        return res;
    }
}

实现三

import java.util.ArrayList;

public class Solution {
    
    ArrayList<Integer> res = new ArrayList<>();
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        quicksort(input,0,input.length-1,k);
        for(int i=0;i<k;i++){
            res.add(input[i]);
        }
        return res;
    }
    
    //快速排序框架
    private void quicksort(int[] nums,int left,int right,int k){
        if(left>=right){
            return;
        }
        int mid = partition(nums,left,right);
        if(mid==k){
            return;
        }
        if(mid<k){
            quicksort(nums,mid+1,right,k);
        }else{
            quicksort(nums,left,mid-1,k);
        }
    }
    
    private int partition(int[] nums,int left,int right){
        //基准数
        int x = nums[left];
        int i = left;
        int j = right+1;
        while(true){
            while(nums[++i]<x){
                if(i>=right){
                    break;
                }
            }
            while(nums[--j]>x);
            if(i>=j) break;
            swap(nums,i,j);
        }
        swap(nums,left,j);
        return j;
        
    }
    
    private void swap(int[] nums,int i,int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
    
    
    
    
    
    
    
}