剑指offer41.数据流中的中位数

我一开始的想法是既然要找中位数,那肯定要排序,而且这个数据结构肯定要能动态的添加数据的,肯定不能用数组,于是我想到了用优先队列,它自己会排序都不用我写,所以addNum方法直接调用就可以,但是找中位数就很麻烦,它不能根据下标访问,于是我写了一个很屎的方法,把它poll到数组里面找到中位数后,再从数组放到优先队列中,代码如下:

java 复制代码
class MedianFinder {
    private PriorityQueue<Integer> priorityQueue;
    /** initialize your data structure here. */
    public MedianFinder() {
       this.priorityQueue = new PriorityQueue<Integer>();
    }
    
    public void addNum(int num) {
        priorityQueue.add(num);
    }
    
    public double findMedian() {
       int size = priorityQueue.size();
       int[] arr = new int[size];
       for(int i=0;i<size;i++){
           arr[i] = priorityQueue.poll();
       }
       for(int i=0;i<size;i++){
           priorityQueue.add(arr[i]);
       }
       if(size%2 != 0){
           return (double)arr[((size+1)/2) -1];
       }else{
           double res = (arr[(size/2)-1] + arr[size/2])/2.0;
           return res;
       }
    }
}

但是它超时了,题目的测试用例非常大,我就想肯定是找中位数的时候太繁琐了,于是就想到了用LinkedList,可以通过下标获取中位数,只需要自己写一个排序,我就想到用add(int index, E element)方法,每次添加的时候找到添加的位置,这样就一直是有序的,复杂度是O(n),于是我又写了如下代码:

java 复制代码
class MedianFinder {
    private LinkedList<Integer> list;
    /** initialize your data structure here. */
    public MedianFinder() {
       this.list = new LinkedList<Integer>();
    }
    
    public void addNum(int num) {
        int size = list.size();
        if(size == 0){
            list.add(num);
            return;
        }else{
            for(int i =0;i<size;i++){
                if(i==0 && num <= list.get(0)){
                    list.addFirst(num);
                    break;
                }else if(i==size-1 && num >= list.get(size-1)){
                        list.addLast(num);
                        break;
                }else if(num >= list.get(i) && num <= list.get(i+1)){
                    list.add(i+1, num);
                    break;
                }else{
                    continue;
                }
            }
        }
    }
    
    public double findMedian() {
         int size = list.size();
         return size%2 !=0 ? list.get(((size+1)/2)-1)*1.0 : (list.get((size/2)-1)+list.get(size/2))/2.0;
    }
}

但是tmd我没想到这也能超时,真进行了5000次的调用,然后我又试了一下用二分查找添加,不行,看题解了。题解看完我只想说一个字,妙!他也是用的优先队列,但是他用了两个优先队列,一个queMax存大于中位数的数,queMin存小于等于中位数的数,如果总数的奇数,那么中位数就是queMin的队头,如果总数是偶数那么中位数就是queMin和queMax的队头的平均值,添加的时候如果num小于等于中位数就加到queMin中,这时候新的中位数可能会小于原来的中位数,就要把queMin的对头放到queMax中,如果num大于中位数同理。

java 复制代码
class MedianFinder {
    private PriorityQueue<Integer> queMin;
    private PriorityQueue<Integer> queMax;
    /** initialize your data structure here. */
    public MedianFinder() {
       queMin = new PriorityQueue<Integer>((a, b) -> (b - a));
       queMax = new PriorityQueue<Integer>((a, b) -> (a - b));
    }
    
    public void addNum(int num) {
        if(queMin.isEmpty() || num <= queMin.peek()){
            queMin.offer(num);
            if(queMax.size() + 1 < queMin.size()){
                queMax.offer(queMin.poll());
            }
        }else{
            queMax.offer(num);
            if(queMax.size() > queMin.size()){
                queMin.offer(queMax.poll());
            }
        }
    }
   
    public double findMedian() {
         if(queMin.size() > queMax.size()){
             return queMin.peek();
         }
         return (queMax.peek() + queMin.peek()) / 2.0;
    }
}

需要注意的是两个队列的排序方法不一样,queMin是队头最大,从大到小排,queMax是队头最小,从小到大排。所以看到两个优先队列的初始化方法是不一样的,lambda表达式中queMin的返回结果是b-a,而queMax是a-b。

相关推荐
间彧17 分钟前
Java线程池详解与实战指南
java
用户2986985301425 分钟前
Java 使用 Spire.PDF 将PDF文档转换为Word格式
java·后端
NAGNIP28 分钟前
Serverless 架构下的大模型框架落地实践
算法·架构
moonlifesudo34 分钟前
半开区间和开区间的两个二分模版
算法
渣哥34 分钟前
ConcurrentHashMap 1.7 vs 1.8:分段锁到 CAS+红黑树的演进与性能差异
java
moonlifesudo37 分钟前
300:最长递增子序列
算法
间彧44 分钟前
复用线程:原理详解与实战应用
java
咖啡Beans2 小时前
使用OpenFeign实现微服务间通信
java·spring cloud
我不是混子2 小时前
说说单例模式
java