[路飞]_js算法：leetcode 面试题 17.20-连续中值

leetcode 面试题 17.20. 连续中值

问题描述： 随机产生数字并传递给一个方法。你能否完成这个方法，在每次产生新值时，寻找当前所有值的中间值（中位数）并保存。

中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。

例如，

[2,3,4] 的中位数是 3

[2,3] 的中位数是 (2 + 3) / 2 = 2.5

设计一个支持以下两种操作的数据结构：

• void addNum(int num) - 从数据流中添加一个整数到数据结构中。
• double findMedian() - 返回目前所有元素的中位数。

示例：

addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3) 
findMedian() -> 2

思路： 维护两个堆 前面是大顶堆 后面是小顶堆 注意，大顶堆数量只能>=小顶堆数量+1

var MedianFinder = function() {
 this.heap1=new Heap((a,b)=>a>b);
 this.heap2=new Heap((a,b)=>a<b);
 return;
};

/** 
 * @param {number} num
 * @return {void}
 */
MedianFinder.prototype.addNum = function(num) {
  if(this.heap1.size==this.heap2.size){
    if(num>this.heap2.top){
      this.heap1.push(this.heap2.pop());
      this.heap2.push(num);
      return;
    }
    this.heap1.push(num);
    return;
    }
  if(this.heap1.size==this.heap2.size+1){
    if(num>this.heap1.top){
      this.heap2.push(num);
      return;
    }
    this.heap1.push(num);
    this.heap2.push(this.heap1.pop());
    return;
  }
};

/**
 * @return {number}
 */
MedianFinder.prototype.findMedian = function() {
 if(!this.heap1.size&&!this.heap2.size)return 0;
  if(this.heap1.size==this.heap2.size) return Number((this.heap1.top+this.heap2.top)/2);
  else{
    return Number((this.heap1.top));
  }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * var obj = new MedianFinder()
 * obj.addNum(num)
 * var param_2 = obj.findMedian()
 */
 //实现堆
 class Heap {
  constructor(cmp) {
      this.data = [];
      this.cmp = cmp;
  }
  get size() {
      return this.data.length;
  }
  get top() {
      return this.data[0];
  }
  getData() {
      return this.data;
  }
  swap(i, j) {
      [this.data[i], this.data[j]] = [this.data[j], this.data[i]];
  }
  // 向上冒泡
  up(i) {
      let index=this.data.length-1;
      while(index>0){
          let p=Math.floor((index-1)/2);
          if(p>=0&&this.cmp(this.data[index],this.data[p])){
              this.swap(index,p);
              index=p;
          }else{
              break;
          }
      }
  }
  // 下沉操作
  down(i) {
    if(this.data.length<2)return;
    let index=0,l=2*index+1,len=this.data.length;
    while(l<len){
      let r=l+1;
      if(r<len&&this.cmp(this.data[r], this.data[l]))l=r;
      if(this.cmp(this.data[index], this.data[l]))break;
      this.swap(index,l)
      index=l;
      l=index*2+1;
    }
  }
  push(item) {
    this.data.push(item);
    this.up();
  }
  //删除堆顶元素
  pop() {
      this.swap(0, this.data.length - 1);
      const res = this.data.pop();//已删除的元素（原来的堆顶元素）
      this.down();
      return res;
  }
}