[算法]最小的K个数和数据流中的中位数

1. 最小的K个数

题目描述

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

思路

Java 中的PriorityQueue是一个基于优先级堆的*优先级队列。优先级队列的元素按照其自然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造方法。优先级队列不允许使用 null 元素。依靠自然顺序的优先级队列还不允许插入不可比较的对象（这样做可能导致 ClassCastException）。

此队列的头是按指定排序方式确定的最小元素。如果多个元素都是最小值，则头是其中一个元素——选择方法是任意的。队列获取操作 poll、 remove、peek 和 element 访问处于队列头的元素。

关于PriorityQueue的更多介绍可以查看：https://blog.****.net/x_i_y_u_e/article/details/46381481。

关于采用PriorityQueue实现最大堆和最小堆，可以参考：http://www.cnblogs.com/yongh/p/9945539.html

https://www.cnblogs.com/Elliott-Su-Faith-change-our-life/p/7472265.html

选择最小的k个数可以用冒泡排序，复杂度为O(n*k)，有点高。最经典的方法是使用最大堆，每次取数与堆顶的元素进行比较，如果堆顶元素大，则删除堆顶元素，并添加这个新数到堆中。

Java没有堆的实现，现场写也来不及，有的文献说用TreeSet，比如剑指offer，但是TreeSet是一个set，相同的数只能存一个，相比之下，Java中的PriorityQueue倒是一个不错的选择。

代码

通过PriorityQueue写法：

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
        if (input == null || k <= 0 || k > input.length) {
            return new ArrayList<Integer>();
        }
        Queue<Integer> queue = new PriorityQueue<>(k, new Comparator<Integer>() {
            //降序
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (int i = 0; i < input.length; i++) {
            if(queue.size() == k){
                if(queue.peek() > input[i]){
                    queue.poll();
                    queue.add(input[i]);
                }
            }else{
                queue.add(input[i]);
            }
        }
        ArrayList<Integer> list = new ArrayList<>(queue);
        return list;
    }
}

自己实现大顶堆写法：

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if (input == null || k <= 0 || k > input.length) {
            return list;
        }
        int[] kArray = Arrays.copyOfRange(input,0,k);
        // 创建大根堆
        buildHeap(kArray);

        for(int i = k; i < input.length; i++) {
            if(input[i] < kArray[0]) {
                kArray[0] = input[i];
                maxHeap(kArray, 0);
            }
        }

        for (int i = kArray.length - 1; i >= 0; i--) {
            list.add(kArray[i]);
        }

        return list;
    }

    public void buildHeap(int[] input) {
        for (int i = input.length/2 - 1; i >= 0; i--) {
            maxHeap(input,i);
        }
    }

    private void maxHeap(int[] array,int i) {
        int left=2*i+1;
        int right=left+1;
        int largest=0;

        if(left < array.length && array[left] > array[i])
            largest=left;
        else
            largest=i;

        if(right < array.length && array[right] > array[largest])
            largest = right;

        if(largest != i) {
            int temp = array[i];
            array[i] = array[largest];
            array[largest] = temp;
            maxHeap(array, largest);
        }
    }

}

2. 数据流中的中位数

题目描述

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

思路

创建优先级队列维护大顶堆和小顶堆两个堆，并且小顶堆的值都大于大顶堆的值，2个堆个数的差值小于等于1，所以当插入个数为奇数时：大顶堆个数就比小顶堆多1，中位数就是大顶堆堆头；当插入个数为偶数时，使大顶堆个数跟小顶堆个数一样，中位数就是 2个堆堆头平均数。也可使用集合类的排序方法。

代码

import java.util.Comparator;
import java.util.PriorityQueue;
public class Solution {

    PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    PriorityQueue<Integer> maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2.compareTo(o1);
        }
    });
    int count = 0;
    public void Insert(Integer num) {
        count++;
        //当数据个数为奇数时，进入大根堆
        if((count & 1) == 1){
            minHeap.add(num);
            maxHeap.add(minHeap.poll());
        }else{
            maxHeap.add(num);
            minHeap.add(maxHeap.poll());
        }
    }

    public Double GetMedian() {
        if(count == 0){
            return null;
        }
        // 当数据个数是奇数时，中位数就是大根堆的顶点
        if ((count & 1) == 1) {
            return Double.valueOf(maxHeap.peek());
        } else {
            return Double.valueOf((minHeap.peek() + maxHeap.peek())) / 2;
        }
    }

}