双堆法实现数据流中位数的高效计算

1. 问题背景与核心挑战

中位数计算是数据处理中的经典问题，但数据流场景下的实时中位数计算带来了独特的挑战。与静态数据集不同，数据流要求我们在无法预知全部数据的情况下，持续维护一个能够快速响应查询的数据结构。

传统的中位数计算需要对数据集进行排序，这在数据流环境中会产生O(nlogn)的时间复杂度，对于高频数据流（如金融行情、传感器数据）完全不可行。更棘手的是，数据流的中位数计算需要满足两个看似矛盾的要求：

• 快速插入：新数据到达时必须高效插入（最好O(logn)）
• 即时查询：随时可能收到查询请求，响应必须接近O(1)

这个看似简单的问题，实际上考察了我们对数据结构的深刻理解和灵活运用能力。这也是为什么这道题能入选LeetCode热题100——它不仅测试基础算法能力，更考察对实际工程场景的抽象能力。

2. 双堆法的设计原理

2.1 数据结构选型分析

面对这个挑战，双堆法（Dual Heap）展现出了优雅的解决方案。它由两个堆组成：

• 最大堆（Max Heap）：存储较小的一半数字
• 最小堆（Min Heap）：存储较大的一半数字

这种设计的精妙之处在于利用了堆的性质：

1. 最大堆的堆顶是较小半数的最大值
2. 最小堆的堆顶是较大半数的最小值
3. 两个堆顶正好"夹住"整个数据集的中位数位置

通过保持两个堆的大小平衡（数量相等或相差1），我们可以确保中位数永远出现在堆顶位置。这种设计将插入复杂度降到了O(logn)，查询复杂度降到了O(1)。

2.2 数学证明与正确性

让我们从数学角度证明这个设计的正确性。对于有序数据集S，中位数定义为：

• 当n为奇数时：S[(n-1)/2]
• 当n为偶数时：(S[n/2-1] + S[n/2])/2

双堆法实际上将数据集S分成两部分：

• 最大堆存储S[0...k]
• 最小堆存储S[k+1...n-1]

通过维护size(maxHeap) - size(minHeap) ∈ {0,1}，我们确保：

• 奇数时：中位数在maxHeap顶
• 偶数时：中位数是两堆顶的平均值

这种分割保证了无论数据如何到达，我们都能在堆顶保持正确的中位数候选。

3. Java实现详解

3.1 基础实现代码

class MedianFinder {
    private PriorityQueue<Integer> maxHeap; // 存储较小的一半
    private PriorityQueue<Integer> minHeap; // 存储较大的一半

    public MedianFinder() {
        maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        minHeap = new PriorityQueue<>();
    }
    
    public void addNum(int num) {
        // 第一步：无条件加入maxHeap
        maxHeap.offer(num);
        
        // 第二步：平衡两个堆
        minHeap.offer(maxHeap.poll());
        
        // 第三步：维持大小关系
        if (maxHeap.size() < minHeap.size()) {
            maxHeap.offer(minHeap.poll());
        }
    }
    
    public double findMedian() {
        if (maxHeap.size() == minHeap.size()) {
            return (maxHeap.peek() + minHeap.peek()) / 2.0;
        } else {
            return maxHeap.peek();
        }
    }
}

3.2 关键操作解析

addNum方法的三个步骤值得深入分析：

1. 初始插入 ：新元素总是先进入maxHeap。这保证了所有元素都会经过"较小半数"的筛选。
2. 平衡交换 ：将maxHeap的最大值移到minHeap。这一步确保了maxHeap中的所有元素都≤minHeap中的元素。
3. 大小调整 ：如果minHeap变得更大，则返还一个元素到maxHeap。这维持了size(maxHeap) ≥ size(minHeap)的不变式。

这种三步操作保证了无论输入顺序如何，数据结构总能保持正确的分割状态。举个例子，对于输入序列[1,2,3,4]：

• 插入1: maxHeap[1], minHeap[]
• 插入2: maxHeap[1], minHeap[2]
• 插入3: maxHeap[1], minHeap[2,3] → 调整 → maxHeap[1,2], minHeap[3]
• 插入4: maxHeap[1,2], minHeap[3,4]

最终中位数计算为(2+3)/2=2.5，完全正确。

4. 复杂度与优化分析

4.1 时间复杂度分解

每个操作的时间复杂度：

• addNum():
  • offer()操作：O(logn)
  • poll()操作：O(logn)
  • 共进行3次堆操作 → 3O(logn) → 仍为O(logn)
• findMedian():
  • peek()操作：O(1)
  • 简单算术运算：O(1)

与朴素方法（维护有序列表）相比：

• 插入：O(logn) vs O(n)
• 查询：O(1) vs O(1)

对于高频插入场景，这种优化是决定性的。例如处理每秒1000次的数据流，朴素方法可能需要数毫秒的插入时间，而双堆法仅需微秒级。

4.2 空间复杂度考量

双堆法需要存储所有元素，空间复杂度为O(n)。虽然这与维护一个数组相同，但实际内存占用会略高，因为堆结构需要额外的指针或索引空间。

在内存受限的环境下，可以考虑以下优化：

1. 元素压缩 ：如果数据范围有限（如0-100的整数），可以用更紧凑的数据类型存储
2. 近似计算 ：允许少量误差的情况下，可以使用采样或草图(sketch)算法
3. 外部存储 ：对于超大规模数据流，可以将部分堆存储在磁盘上（但会显著降低性能）

5. 边界条件与异常处理

5.1 数值边界情况

实际实现中需要考虑以下边界条件：

1. 整数溢出 ：当处理极大整数时，两数相加可能导致溢出

   // 不安全的做法
   return (maxHeap.peek() + minHeap.peek()) / 2.0;
   
   // 安全的做法
   double a = maxHeap.peek();
   double b = minHeap.peek();
   return (a + b) / 2.0;
   

2. 空流查询 ：在没有任何数据时调用findMedian()

   public double findMedian() {
       if (maxHeap.isEmpty()) {
           throw new IllegalStateException("No data available");
       }
       // ...原有逻辑
   }
   

5.2 并发访问问题

标准