Java求解最大的k个数和最小的k个数

Java求解最大的k个数和最小的k个数

1. 最大的k个数

解题思路

代码使用了一个优先队列（PriorityQueue）来实现。优先队列是一种根据元素的优先级进行排序的数据结构，这里我们使用顺序排列，即小顶堆。初始时，我们将数组中的前k个元素加入到优先队列中。

然后，遍历数组剩余的元素，如果当前元素比优先队列中的堆顶元素（最小元素）大，则将堆顶元素出队，将当前元素加入优先队列。

最后，将优先队列中的元素依次取出，并将它们存放到结果数组result中。由于优先队列已经按照顺序排列，所以取出的元素会按照升序存放在result中。

因此，这段代码求得的是数组arr中最大的k个数，并将它们存放在结果数组result中。

package day902;

import java.util.PriorityQueue;

/**
 * 最大的k个数
 */

public class GetLargestNumbers {
    public static void main(String[] args) {
        int []arr = {10,31,455,62,7,822,9};
        int k = 4;
        int []result = getLargestNumbers(arr,k);
        for(int num : result) {
            System.out.println(num);
        }
    }
    public static int[] getLargestNumbers(int[] arr, int k) {
        if (k == 0) {
            return new int[0];
        }
        PriorityQueue<Integer> heap = new PriorityQueue<>(k);
        for (int i = 0; i < k; i++) {
            heap.offer(arr[i]);
        }
        for (int i = k; i < arr.length; i++) {
            if(arr[i] > heap.peek()) {
                heap.poll();
                heap.offer(arr[i]);
            }
        }
        int []result = new int[k];
        int index = 0;
        for(int num : heap) {
            result[index++]= num;
        }
        return result;
    }
}

2. 最小的K个数

解题思路

代码使用了一个优先队列（PriorityQueue）来实现。优先队列是一种根据元素的优先级进行排序的数据结构，这里我们使用逆序排列，即大顶堆。初始时，我们将数组中的前k个元素加入到优先队列中。

然后，遍历数组剩余的元素，如果当前元素比优先队列中的堆顶元素（最大元素）小，则将堆顶元素出队，将当前元素加入优先队列。

最后，将优先队列中的元素依次取出，并将它们存放到结果数组result中。由于优先队列已经按照逆序排列，所以取出的元素会按照降序存放在result中。

因此，这段代码求得的是数组arr中最小的k个数，并将它们存放在结果数组result中。

package day828;


import java.util.Collections;
import java.util.PriorityQueue;

/**
 * 最小的k个数
 */

public class GetLeastNumbers {
    public static void main(String[] args) {
        int []arr = {10,31,455,62,7,822,9};
        int k = 4;
        int []result = getLeastNumbers(arr,k);
        for(int num : result) {
            System.out.println(num);
        }
    }
    public static int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0) {
            return new int[0];
        }

        PriorityQueue<Integer> heap = new PriorityQueue<>(k, Collections.reverseOrder());
        for (int i = 0; i < k; i++) {
            heap.offer(arr[i]);
        }

        for (int i = k; i < arr.length; i++) {
            if (arr[i] < heap.peek()) {
                heap.poll();
                heap.offer(arr[i]);
            }
        }
        //将优先队列中的元素依次取出，并存放到结果数组`result`中
        int[] result = new int[k];
        int index = 0;
        for (int num : heap) {
            result[index++] = num;
        }

        return result;
    }
}

补充

• peek(): 返回队列的头部元素，但并不删除该元素。如果队列为空，则返回 null。
• poll(): 返回队列的头部元素，并将其从队列中删除。如果队列为空，则返回 null。
• offer(): 将指定的元素插入到队列的尾部。如果队列已满，则返回 false；否则返回 true。