LeetCode295. 数据流的中位数🌟🌟🌟🌟困难

课后作业

问题描述

原文链接:295. 数据流的中位数

中位数是有序整数列表中的中间值。如果列表的大小是偶数,则没有中间值,中位数是两个中间值的平均值。

  • 例如 arr = [2,3,4] 的中位数是 3 。
  • 例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5 。

实现 MedianFinder 类:

  • MedianFinder()初始化 MedianFinder 对象。
  • void addNum(int num) 将数据流中的整数 num 添加到数据结构中。
  • double findMedian() 返回到目前为止所有元素的中位数。与实际答案相差 10-5 以内的答案将被接受。

示例 1:

输入
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
输出
[null, null, null, 1.5, null, 2.0]

解释
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1);    // arr = [1]
medianFinder.addNum(2);    // arr = [1, 2]
medianFinder.findMedian(); // 返回 1.5 ((1 + 2) / 2)
medianFinder.addNum(3);    // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

提示:

  • -105 <= num <= 105
  • 在调用 findMedian 之前,数据结构中至少有一个元素
  • 最多 5 * 104 次调用 addNum 和 findMedian

代码实现

Java

class MedianFinder {
    //
    Queue<Integer> max;// 保存较小那部分,并且多保存一个
    Queue<Integer> min;// 保存较大那部分

    public MedianFinder() {
        max = new PriorityQueue<>((x,y)->(y - x));
        min = new PriorityQueue<>();
    }

    public void addNum(int num) {
        // 偶数
        if(max.size() == min.size()){
            min.offer(num);
            max.offer(min.poll());
        } else {
            max.offer(num);
            min.offer(max.poll());
        }
    }

    public double findMedian() {
        int size = max.size() + min.size();
        if(size % 2 == 1){
            return max.peek() * 1.0;
        }else{
            return (max.peek() + min.peek()) / 2.0;
        }
    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

Python

class MedianFinder(object):
    def __init__(self):
        self.max = [] # 保存较小那部分,并且多保存一个
        self.min = [] # 保存较大那部分

    def addNum(self, num):
        # 偶数
        if len(self.max) == len(self.min):
            heapq.heappush(self.min, num)
            heapq.heappush(self.max, -heapq.heappop(self.min))
        else:
            heapq.heappush(self.max, -num)
            heapq.heappush(self.min, -heapq.heappop(self.max))

    def findMedian(self):
        size = len(self.max) + len(self.min)
        if size % 2 == 1:
            return float(-self.max[0])
        else:
            return (float(-self.max[0]) + float(self.min[0])) / 2

# Your MedianFinder object will be instantiated and called as such:
# obj = MedianFinder()
# obj.addNum(num)
# param_2 = obj.findMedian()

C++

class MedianFinder {
private:
    priority_queue<int> max; // 保存较小那部分,并且多保存一个
    priority_queue<int, vector<int>, greater<int>> min; // 保存较大那部分

public:
    MedianFinder() {

    }

    void addNum(int num) {
        // 偶数
        if(max.size() == min.size()){
            min.push(num);
            max.push(min.top());
            min.pop();
        } else {
            max.push(num);
            min.push(max.top());
            max.pop();
        }
    }

    double findMedian() {
        int size = max.size() + min.size();
        if(size % 2 == 1){
            return max.top() * 1.0;
        }else{
            return (max.top() + min.top()) / 2.0;
        }
    }
};

// Your MedianFinder object will be instantiated and called as such:
// MedianFinder* obj = new MedianFinder();
// obj->addNum(num);
// double param_2 = obj->findMedian();

发表回复

后才能评论

评论(7)

  • 笨笨小子 永久会员 2024年8月4日 下午3:25

    打卡

  • Mr.肖 永久会员 2024年4月4日 下午6:21
    class MedianFinder {
    
    
        PriorityQueue<Integer> max = new PriorityQueue<>((x,y) -> y-x);
        PriorityQueue<Integer> min = new PriorityQueue<>();
        public MedianFinder() {
    
        }
    
        /**
            和帅地的思路做一个反向(小顶堆多保存一个元素)
            当元素个数为偶数的时候,我们让小顶堆多保存一个元素:先向大顶堆添加元素,大顶堆出一个元素到小顶堆
            当元素个数为奇数的时候,先向小顶堆添加元素,小顶堆再出一个元素到大顶堆中
            易错点:多保存的那个元素是从另一个堆中poll()出来的,不是我们添加进去的,这样才能保证两个堆中元素的有序性
         */
    
        public void addNum(int num) {
            if(max.size() == min.size()){
                max.offer(num);
                min.offer(max.poll());
            }else{
               min.offer(num);
               max.offer(min.poll());
            }
        }
    
        public double findMedian() {
            int n = max.size() + min.size();
            if(n % 2 == 1){
                return min.peek() * 1.0;
            }else{
                return (max.peek() + min.peek()) / 2.0;
            }
        }
    }
    
    /**
     * Your MedianFinder object will be instantiated and called as such:
     * MedianFinder obj = new MedianFinder();
     * obj.addNum(num);
     * double param_2 = obj.findMedian();
     */
    
  • 少年不识流川枫 永久会员 2024年2月29日 下午8:22
    class MedianFinder {
        // 大根堆的peek返回最大的数,小根堆peek返回最小的数
        Queue max;  // 大根堆保存较小的数,例如1,2 
        Queue min;  // 小根堆保存较大的数,例如3,4
    
        public MedianFinder() {
            max = new PriorityQueue<>((x,y) -> (y - x));
            min = new PriorityQueue<>();
    
        }
    
        public void addNum(int num) {
            // 判断奇偶性,用两边的大小size()比较 ==是偶数,
            int sum = max.size() + min.size();
         
    
             if(sum % 2 == 0){
                // if(num > min.peek()){  // 例如max = 1,3   min= 7,9  此时进来8比7大,应该8进min中,7放进max,  进来4
                //     max.offer(min.poll());
                //     min.offer(num);
                // }
                // max.offer(num); //不用比较大小,因为优先队列就会自动比较大小
    
                min.offer(num);
                max.offer(min.poll());
            }else{ 
                // if(num < max.peek().intValue()){
                //     max.offer(num);
                //     min.offer(max.poll());
                // }
                // min.offer(num);
    
                max.offer(num);
                min.offer(max.poll());
            }
        }
    
        public double findMedian() {
            int size = max.size() + min.size();
            if(size % 2 == 1){
                return max.peek() * 1.0;
            }else{
                return (max.peek() + min.peek()) / 2.0;
            }
    
        }
    }
    

    //不用比较大小,因为优先队列就会自动比较大小

  • uu 永久会员 2023年10月12日 下午9:00
    class MedianFinder {
        Queue<Integer> max; //大根堆存放较小的元素
        Queue<Integer> min; //小根堆存放较大的元素
        //如果二者大小相同,新入num存入min再poll到max 或 中位数为max堆顶与min堆顶之和的二分之一
    
    <pre><code>public MedianFinder() {
        max = new PriorityQueue<>((x, y) -> (y - x));
        min = new PriorityQueue<>();
    }
    
    public void addNum(int num) {
        if(max.size() == min.size()) {
            min.offer(num);
            max.offer(min.poll());
        }
        else {
            max.offer(num);
            min.offer(max.poll());
        }
    }
    
    public double findMedian() {
        return max.size() != min.size() ? max.peek() * 1.0 : (min.peek() + max.peek()) / 2.0;
    }
    </code></pre>
    
    }
    
    
  • 泡芙 永久会员 2023年9月18日 上午11:22
    • Time:O(log⁡N),查找中位数 O(1): 获取堆顶元素使用 O(1)时间。添加数字 O(log⁡N): 堆的插入和弹出操作使用 O(logN) 时间。
    • Space:O(N) : 其中 N 为数据流中的元素数量,小根堆 min 和大根堆 max 最多同时保存 N 个元素。
    class MedianFinder {
        // new两个优先队列
        Queue<Integer> max;
        Queue<Integer> min;
    
        public MedianFinder() {
            // 大根堆
            max = new PriorityQueue<>((x, y) -> (y - x));
            // 小根堆
            min = new PriorityQueue<>();
        }
    
        public void addNum(int num) {
            // 大根堆为偶数,先放入小根堆中,再把小根堆堆顶元素放入大根堆中
            if (max.size() == min.size()) {
                min.offer(num);
                max.offer(min.poll());
            } else {
                max.offer(num);
                min.offer(max.poll());
            }
        }
    
        // 注意:Integer转为double
        public double findMedian() {
            int size = max.size() + min.size();
            // 如果元素是奇数个,大根堆的堆顶元素是中位数
            if (size % 2 == 1) {
                return max.peek() * 1.0;
            } else {
                // 如果元素是偶数个,两个堆堆顶元素的平均数是中位数
                return (max.peek() + min.peek()) / 2.0;
            }
        }
    }
    
  • 阿尚 普通 2023年8月19日 下午8:22
    class MedianFinder {
        PriorityQueue<Integer> low;//放前一半数
        PriorityQueue<Integer> high;//放后一半数
        public MedianFinder() {
            low = new PriorityQueue<>((x, y) -> Integer.compare(y, x)); //大顶堆
            high = new PriorityQueue<>(); //小顶堆
        }
    
        public void addNum(int num) {
            if(low.size() <= high.size()){
                high.offer(num);
                low.offer(high.poll());
            }else{
                low.offer(num);
                high.offer(low.poll());
            }
        }
    
        public double findMedian() {
            if(low.size() == high.size()) return (low.peek() + high.peek()) / 2.0;//注意:除数是2.0,返回类型是double类型
            return low.size() > high.size() ? low.peek() : high.peek();
        }
    }
    
  • 帅气的冬瓜 普通 2023年7月3日 下午2:16

    打卡

如果您已经成功付款但是网站没有弹出成功提示,请联系站长提供付款信息为您处理