一个数据流中，随时可以取得中位数

思路：这题的思路就是利用两个堆来做。一个大根堆用来储存比较小的数据，以及一个小跟堆用来储存较大的数据。

package Code07;

import java.util.PriorityQueue;

public class Code04_MedianQuick {
    public static void main(String[] args) {
        MedianHolder m = new MedianHolder();
        m.addNumber(3);
        m.addNumber(10);
        m.addNumber(5);
       // m.addNumber(6);
        int res = m.getMedian();
        System.out.println(res);
    }
    public static class MedianHolder{
        private PriorityQueue<Integer> maxHeap = new PriorityQueue<>((Integer o1, Integer o2) ->{return o2 - o1;});
        private PriorityQueue<Integer> minHeap = new PriorityQueue<>((Integer o1, Integer o2) ->{return o1 - o2;});
        private void modifyTwoHeapSize(){
            if(this.maxHeap.size() == this.minHeap.size() + 2){
                this.minHeap.add(this.maxHeap.poll());
            }
            if(this.minHeap.size() == this.maxHeap.size() + 2){
                this.maxHeap.add(this.minHeap.poll());
            }
        }
        public void addNumber(int num){
            if(this.maxHeap. isEmpty()){
                this.maxHeap.add(num);
                return ;
            }
            if(this.maxHeap.peek() >= num){
                this.maxHeap.add(num);
            }else{
                if(this.minHeap.isEmpty()){
                    this.minHeap.add(num);
                    return ;
                }
                if(this.minHeap.peek() > num){
                    this.maxHeap.add(num);
                }else{
                    this.minHeap.add(num);
                }
            }
            modifyTwoHeapSize();
        }
        public Integer getMedian(){
            int maxHeapSize = maxHeap.size();
            int minHeapSize = minHeap.size();
            if(maxHeapSize + minHeapSize == 0){
                return null;
            }
            Integer maxHeapHead = this.maxHeap.peek();
            Integer minHeapHead = this.minHeap.peek();
            if(((maxHeapSize + minHeapSize) & 1) == 0){
                return (minHeapHead + maxHeapHead) / 2;
            }
            return maxHeapSize > minHeapSize ? maxHeapHead : minHeapHead;
        }

    }
}