剑指offer_最小的k个数

题目描述

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

方法一：第一反应就是排序，选前k个

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
             ArrayList<Integer> resultList= new ArrayList<>();
             if(k>input.length) return resultList;
             Arrays.sort(input);
             int[] copyOf = Arrays.copyOf(input,k);
             
             for(int num : copyOf){
                resultList.add(num);
            }
            return resultList;
    }
}

方法二：利用快速排序的方法

快速排序的partition方法，会返回一个整数j使得a[1...j-1]小于等于a[j]，且a[j+1...h]大于等于a[j]，此时a[j]就是数组的第j大元素，可以利用这个特性找出数组的第K个元素，这种找第k个元素的算法被称为快速选择算法

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
        ArrayList<Integer> ret = new ArrayList<>();
        if (k > nums.length || k <= 0)
        return ret;
        findKthSmallest(nums, k - 1);
        /* findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数 */
        for (int i = 0; i < k; i++)
            ret.add(nums[i]);
        return ret;
    }
    public void findKthSmallest(int[] nums, int k) {
        int l = 0, h = nums.length - 1;
        while (l < h) {
            int j = partition(nums, l, h);
            if (j == k)
                break;
            if (j > k)
                h = j - 1;
            else
            l = j + 1;
        }
    }
    private int partition(int[] nums, int l, int h) {
        int p = nums[l]; /* 切分元素 */
        int i = l, j = h + 1;
        while (true) {
        while (i != h && nums[++i] < p) ;
        while (j != l && nums[--j] > p) ;
        if (i >= j)
        break;
        swap(nums, i, j);
        }
        swap(nums, l, j);
        return j;
    }
    private void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }
}

 

方法三：大顶堆

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        if (k > input.length || k <= 0)
            return new ArrayList<>();
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1,o2)->o2-o1);
        for(int num : input){
            maxHeap.add(num);
            if(maxHeap.size()>k)
                maxHeap.poll();
        }
        return new ArrayList<>(maxHeap);
    }
}