最大堆和最小堆求数据流中的中位数【java实现】



import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class FindMedianInStream {
 
 private static class Heap<T>{
  //堆中元素存放的集合
  private List<T> data;
  //比较器
  private Comparator<T> cmp;
  //构造函数
  public Heap(Comparator<T> cmp){
   this.cmp=cmp;
   this.data=new ArrayList<>(64);
  }
  //向上调整堆， idx,被上移元素的起始位置
  public void shiftUp(int idx){
   if(idx<0||idx>=data.size()){
    throw new IllegalArgumentException(idx+"");
   }
   //获取开始调整的元素对象
   T intentT=data.get(idx);
   //如果不是根元素，则需要上移
   while(idx>0){
    int parentidx=(idx-1)/2;
    T parentT=data.get(parentidx);
    //上移条件，子节点比父节点大，此处定义的大是以比较器返回值为准
    if(cmp.compare(intentT, parentT)>0){
        //将父节点向下放
     data.set(idx, parentT);
     //记录父节点下放的位置
     idx=parentidx; 
    //子节点不比父节点大，说明父子路径已经按从大到小排好顺序了，不需要调整了
    }else{
     break;
    }
   }
   //index此时记录的是最后一个被下放的父节点的位置（也可能是自身）
   //所以将最开始的调整的元素值放入index位置即可
   data.set(idx, intentT);
  }
  //向下调整堆，idx被下移的元素的起始位置
  public void shiftDown(int idx){
   if(idx<0||idx>=data.size()){
    throw new IllegalArgumentException(idx+"");
   }
   T intentT=data.get(idx);
   int leftidex=idx*2+1;
   while(leftidex<data.size()){
    //取左节点的元素对象，并且假定其为2个子节点中最大的
    T maxchild=data.get(leftidex);
    //2个子节点中最大节点元素的位置，假定开始时为左子节点的位置
    int maxidx=leftidex;
    //获取右子节点的位置
    int rightidx=leftidex+1;
    if(rightidx<data.size()){
     T rightchildT=data.get(rightidx);
     //找出2个子节点中的最大子节点
     if(cmp.compare(rightchildT, maxchild)>0){
      maxchild=rightchildT;
      maxidx=rightidx;
     }
    }
    //如果最大子节点比父节点大，则需要向下调整
    if(cmp.compare(maxchild, intentT)>0){
     data.set(idx, maxchild);
     idx=maxidx;
     leftidex=2*idx+1;
    }
    //如果最大子节点不比父节点大，说明父子路径已经按照从大到小排好序了，不需要调整了
    else{
     break;
    }
   }
   data.set(idx, intentT);
  }
  //添加一个元素
  public void add(T item){
   //添加元素到最后
   data.add(item);
   //上移，以完成重构
   shiftUp(data.size()-1);
  }
  //删除堆顶节点
  public T deleteTop(){
   //如果堆已经为空，就抛出异常
   if(data.isEmpty()){
    throw new RuntimeException("The heap is empty.");
   }
   //获取堆顶元素
   T firstT=data.get(0);
   //删除最后一个元素
   T lastT=data.remove(data.size()-1);
   //删除元素后，如果堆为空的情况下，说明删除的元素也是堆顶元素
   if(data.size()==0){
    return lastT;
   }else{
    //将删除的元素放到堆顶
    data.set(0, lastT);
    //自上向下调整堆
    shiftDown(0);
    //返回堆顶元素
    return firstT;
   }
  }
  //获取堆顶节点，但不删除
  public T gettop(){
   if(data.isEmpty()){
    throw new RuntimeException("The heap is empty.");
   }
   return data.get(0);
  }
  //获取堆的大小
  public int size(){
   return data.size();
  }
  //判断堆是否为空
  public boolean isEmpty(){
   return data.isEmpty();
  }
  //清空堆
  public void clear(){
   data.clear();
  }
  //获取堆中的所有数据
  public List<T> getData(){
   return data;
  }
 }
 
 
 /**
  * 升序比较器
  * @param args
  */
 private static class IncComparator implements Comparator<Integer>{

  @Override
  public int compare(Integer o1, Integer o2) {
   // TODO Auto-generated method stub
   return o1-o2;
  }
  
 }
 
 /**
  * 降序比较器
  * @param args
  */
 private static class DescComparator implements Comparator<Integer>{

  @Override
  public int compare(Integer o1, Integer o2) {
   // TODO Auto-generated method stub
   return o2-o1;
  }
  
 }
 
 private static class DynamicArray{
  private Heap<Integer> max;
  private Heap<Integer> min;
  
  public DynamicArray(){
   max=new Heap<>(new IncComparator());
   min=new Heap<>(new DescComparator());
  }
  
  //插入数据
  public void insert(Integer num){
   //已经有偶数个数据了（可能没有数据）
   //数据总是偶数个时把新数据插入到小堆中
   if((min.size()+max.size())%2==0){
    //大堆中有数据，并且插入的元素比大堆中的元素小
    if(max.size()>0 && num<max.gettop()){
     //将num插入到大堆中
     max.add(num);
     //删除堆顶元素，大堆中的最大元素
     num=max.deleteTop();
    }
    min.add(num);
   }
   //数据总是奇数个时把新数据插入到大堆中
   else{
    //小堆中有数据，并且插入的元素比小堆中的元素大
    if(min.size()>0 && num>min.size()){
     min.add(num);
     num=min.deleteTop();
    }
    max.add(num);
   }
  }
  
  public double getMedian(){
   int size=max.size()+min.size();
   if(size==0){
    throw new RuntimeException("No number is available");
   }
   if((size&1)==1){
    return min.gettop();
   }else{
    return (max.gettop()+min.gettop())/2.0;
   }
  }
 }

 public static void main(String[] args) {
  DynamicArray array = new DynamicArray();
  array.insert(5);
  System.out.println(array.getMedian()); // 5  
  array.insert(2);
  System.out.println(array.getMedian()); // 3.5  
  array.insert(3);
  System.out.println(array.getMedian()); // 3  
  array.insert(4);
  System.out.println(array.getMedian()); // 3.5
  array.insert(1);
  System.out.println(array.getMedian()); // 3 
  array.insert(6);
     System.out.println(array.getMedian()); // 3.5 
     array.insert(7);
  System.out.println(array.getMedian()); // 4  
  array.insert(0);
        System.out.println(array.getMedian()); // 3.5
     array.insert(8);
        System.out.println(array.getMedian()); // 4
 }

}