Question

295. 数据流的中位数

English Version

题目描述

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

• 例如 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

解法

方法一：优先队列（双堆）

创建大根堆、小根堆，其中：大根堆存放较小的一半元素，小根堆存放较大的一半元素。

添加元素时，先放入小根堆，然后将小根堆对顶元素弹出并放入大根堆（使得大根堆个数多 $1$）；若大小根堆元素个数差超过 $1$，则将大根堆元素弹出放入小根堆。

取中位数时，若大根堆元素较多，取大根堆堆顶，否则取两堆顶元素和的平均值。

时间复杂度分析：

每次添加元素的时间复杂度为 $O(\log n)$，取中位数的时间复杂度为 $O(1)$。

class MedianFinder:
  def __init__(self):
    """
    initialize your data structure here.
    """
    self.h1 = []
    self.h2 = []

  def addNum(self, num: int) -> None:
    heappush(self.h1, num)
    heappush(self.h2, -heappop(self.h1))
    if len(self.h2) - len(self.h1) > 1:
      heappush(self.h1, -heappop(self.h2))

  def findMedian(self) -> float:
    if len(self.h2) > len(self.h1):
      return -self.h2[0]
    return (self.h1[0] - self.h2[0]) / 2


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

class MedianFinder {
  private PriorityQueue<Integer> q1 = new PriorityQueue<>();
  private PriorityQueue<Integer> q2 = new PriorityQueue<>(Collections.reverseOrder());

  /** initialize your data structure here. */
  public MedianFinder() {
  }

  public void addNum(int num) {
    q1.offer(num);
    q2.offer(q1.poll());
    if (q2.size() - q1.size() > 1) {
      q1.offer(q2.poll());
    }
  }

  public double findMedian() {
    if (q2.size() > q1.size()) {
      return q2.peek();
    }
    return (q1.peek() + q2.peek()) * 1.0 / 2;
  }
}

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

class MedianFinder {
public:
  /** initialize your data structure here. */
  MedianFinder() {
  }

  void addNum(int num) {
    q1.push(num);
    q2.push(q1.top());
    q1.pop();
    if (q2.size() - q1.size() > 1) {
      q1.push(q2.top());
      q2.pop();
    }
  }

  double findMedian() {
    if (q2.size() > q1.size()) {
      return q2.top();
    }
    return (double) (q1.top() + q2.top()) / 2;
  }

private:
  priority_queue<int, vector<int>, greater<int>> q1;
  priority_queue<int> q2;
};

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

type MedianFinder struct {
  q1 hp
  q2 hp
}

/** initialize your data structure here. */
func Constructor() MedianFinder {
  return MedianFinder{hp{}, hp{}}
}

func (this *MedianFinder) AddNum(num int) {
  heap.Push(&this.q1, num)
  heap.Push(&this.q2, -heap.Pop(&this.q1).(int))
  if this.q2.Len()-this.q1.Len() > 1 {
    heap.Push(&this.q1, -heap.Pop(&this.q2).(int))
  }
}

func (this *MedianFinder) FindMedian() float64 {
  if this.q2.Len() > this.q1.Len() {
    return -float64(this.q2.IntSlice[0])
  }
  return float64(this.q1.IntSlice[0]-this.q2.IntSlice[0]) / 2.0
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * obj := Constructor();
 * obj.AddNum(num);
 * param_2 := obj.FindMedian();
 */

type hp struct{ sort.IntSlice }

func (h hp) Less(i, j int) bool { return h.IntSlice[i] < h.IntSlice[j] }
func (h *hp) Push(v any)    { h.IntSlice = append(h.IntSlice, v.(int)) }
func (h *hp) Pop() any {
  a := h.IntSlice
  v := a[len(a)-1]
  h.IntSlice = a[:len(a)-1]
  return v
}

class MedianFinder {
  private nums: number[];

  constructor() {
    this.nums = [];
  }

  addNum(num: number): void {
    const { nums } = this;
    let l = 0;
    let r = nums.length;
    while (l < r) {
      const mid = (l + r) >>> 1;
      if (nums[mid] < num) {
        l = mid + 1;
      } else {
        r = mid;
      }
    }
    nums.splice(l, 0, num);
  }

  findMedian(): number {
    const { nums } = this;
    const n = nums.length;
    if ((n & 1) === 1) {
      return nums[n >> 1];
    }
    return (nums[n >> 1] + nums[(n >> 1) - 1]) / 2;
  }
}

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

struct MedianFinder {
  nums: Vec<i32>,
}

/**
 * `&self` means the method takes an immutable reference.
 * If you need a mutable reference, change it to `&mut self` instead.
 */
impl MedianFinder {
  /** initialize your data structure here. */
  fn new() -> Self {
    Self { nums: Vec::new() }
  }

  fn add_num(&mut self, num: i32) {
    let mut l = 0;
    let mut r = self.nums.len();
    while l < r {
      let mid = (l + r) >> 1;
      if self.nums[mid] < num {
        l = mid + 1;
      } else {
        r = mid;
      }
    }
    self.nums.insert(l, num);
  }

  fn find_median(&self) -> f64 {
    let n = self.nums.len();
    if (n & 1) == 1 {
      return f64::from(self.nums[n >> 1]);
    }
    f64::from(self.nums[n >> 1] + self.nums[(n >> 1) - 1]) / 2.0
  }
}/**
 * Your MedianFinder object will be instantiated and called as such:
 * let obj = MedianFinder::new();
 * obj.add_num(num);
 * let ret_2: f64 = obj.find_median();
 */

/**
 * initialize your data structure here.
 */
var MedianFinder = function () {
  this.val = [];
};

/**
 * @param {number} num
 * @return {void}
 */
MedianFinder.prototype.addNum = function (num) {
  let left = 0;
  let right = this.val.length;
  while (left < right) {
    let mid = left + ~~((right - left) / 2);
    if (num > this.val[mid]) {
      left = mid + 1;
    } else {
      right = mid;
    }
  }
  this.val.splice(left, 0, num);
};

/**
 * @return {number}
 */
MedianFinder.prototype.findMedian = function () {
  let mid = ~~(this.val.length / 2);
  return this.val.length % 2 ? this.val[mid] : (this.val[mid - 1] + this.val[mid]) / 2;
};

public class MedianFinder {
  private List<int> nums;
  private int curIndex;

  /** initialize your data structure here. */
  public MedianFinder() {
    nums = new List<int>();
  }

  private int FindIndex(int val) {
    int left = 0;
    int right = nums.Count - 1;
    while (left <= right) {
      int mid = left + (right - left) / 2;
      if (val > nums[mid]) {
        left = mid + 1;
      } else {
        right = mid - 1;
      }
    }
    return left;
  }

  public void AddNum(int num) {
    if (nums.Count == 0) {
      nums.Add(num);
      curIndex = 0;
    } else {
      curIndex = FindIndex(num);
      if (curIndex == nums.Count) {
        nums.Add(num);
      } else {
        nums.Insert(curIndex, num);
      }
    }
  }

  public double FindMedian() {
    if (nums.Count % 2 == 1) {
      return (double)nums[nums.Count / 2];
    } else {
      if (nums.Count == 0) {
        return 0;
      } else {
        return (double) (nums[nums.Count / 2 - 1] + nums[nums.Count / 2]) / 2;
      }
    }
  }
}

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