随时找到数据流的中位数

【题目】
有一个源源不断地吐出整数的数据流，假设你有足够的空间来保存吐出的数。请设计一个名叫MedianHolder的结构，MedianHolder可以随时取得之前吐出所有数的中位数。
【要求】

1．如果MedianHolder已经保存了吐出的N个数，那么任意时刻将一个新数加入到MedianHolder的过程，其时间复杂度是O(logN)。2．取得已经吐出的N个数整体的中位数的过程，时间复杂度为O(1)。

思路：

        题目要求能随时取得所有数的中位数，如果采用数组结构，增加一个数代价很低O(1)，但是不断增加数据导致数组需要扩容，本题要求取得所有数的中位数，而每次增加一个数都要排序，时间复杂度至少O(N*logN)，因此不现实。

        数组排序后中间的数为中位数。数组数据一半划分到大根堆，一半划分到小根堆，两个堆中元素个数和为偶数时，中位数是两个堆的堆顶相加除以2，两个堆中元素个数和为奇数时，中位数是堆元素个数多的那个堆顶。此方法没有排序。怎样把数据放入到大根堆和小根堆？

        建立两个辅助堆，一个大根堆，一个小根堆。我们规定不断将数放入大根堆，其实也可以不断往小根堆里插入。先一个数（例如5）先往大根堆里放，然后继续增加数（例如4），如果加入的数小于大根堆的堆顶（4<5），则将这个数放入到大根堆中，此时大根堆里有两个数（5和4）。因为此时小根堆里的数量为0，如果两个堆中的数量差值等于2，就将数量多的堆中的一个数放入到数量少的堆中。该拿哪个数放入另一个堆中呢？堆顶。这里要注意：在不断往堆里添加数时（heapInsert过程），也要同时调整堆的结构，新增数后仍要保持大根堆或小根堆的结构（heapify过程）。此时小根堆里有一个数（5），大根堆里有一个数（4），然后再往大根堆里添加一个数不断循环这个过程。

时间复杂度：往堆里插入数的代价为O(logN)，poll操作也是O(logN)。

联想：如果一组数要找出最大数（最小数），并且弹出最大数（最小数）后继续找出剩余数的最大数（最小数），考虑堆结构。

代码：

public class Code_01_MadianQuick {

	public static class MedianHolder {
		private PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(new MaxHeapComparator());
		private PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>(new MinHeapComparator());

		private void modifyTwoHeapsSize() {
			if (this.maxHeap.size() == this.minHeap.size() + 2) {
				this.minHeap.add(this.maxHeap.poll());
			}
			if (this.minHeap.size() == this.maxHeap.size() + 2) {
				this.maxHeap.add(this.minHeap.poll());
			}
		}

		public void addNumber(int num) {
			if (this.maxHeap.isEmpty()) {
				this.maxHeap.add(num);
				return;
			}
			if (this.maxHeap.peek() >= num) {
				this.maxHeap.add(num);
			} else {
				if (this.minHeap.isEmpty()) {
					this.minHeap.add(num);
					return;
				}
				if (this.minHeap.peek() > num) {
					this.maxHeap.add(num);
				} else {
					this.minHeap.add(num);
				}
			}
			modifyTwoHeapsSize();
		}

		public Integer getMedian() {
			int maxHeapSize = this.maxHeap.size();
			int minHeapSize = this.minHeap.size();
			if (maxHeapSize + minHeapSize == 0) {
				return null;
			}
			Integer maxHeapHead = this.maxHeap.peek();
			Integer minHeapHead = this.minHeap.peek();
			if (((maxHeapSize + minHeapSize) & 1) == 0) {
				return (maxHeapHead + minHeapHead) / 2;
			}
			return maxHeapSize > minHeapSize ? maxHeapHead : minHeapHead;
		}

	}

	public static class MaxHeapComparator implements Comparator<Integer> {
		@Override
		public int compare(Integer o1, Integer o2) {
			if (o2 > o1) {
				return 1;
			} else {
				return -1;
			}
		}
	}

	public static class MinHeapComparator implements Comparator<Integer> {
		@Override
		public int compare(Integer o1, Integer o2) {
			if (o2 < o1) {
				return 1;
			} else {
				return -1;
			}
		}
	}

	// for test
	public static int[] getRandomArray(int maxLen, int maxValue) {
		int[] res = new int[(int) (Math.random() * maxLen) + 1];
		for (int i = 0; i != res.length; i++) {
			res[i] = (int) (Math.random() * maxValue);
		}
		return res;
	}

	// for test, this method is ineffective but absolutely right
	public static int getMedianOfArray(int[] arr) {
		int[] newArr = Arrays.copyOf(arr, arr.length);
		Arrays.sort(newArr);
		int mid = (newArr.length - 1) / 2;
		if ((newArr.length & 1) == 0) {
			return (newArr[mid] + newArr[mid + 1]) / 2;
		} else {
			return newArr[mid];
		}
	}

	public static void printArray(int[] arr) {
		for (int i = 0; i != arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		boolean err = false;
		int testTimes = 200000;
		for (int i = 0; i != testTimes; i++) {
			int len = 30;
			int maxValue = 1000;
			int[] arr = getRandomArray(len, maxValue);
			MedianHolder medianHold = new MedianHolder();
			for (int j = 0; j != arr.length; j++) {
				medianHold.addNumber(arr[j]);
			}
			if (medianHold.getMedian() != getMedianOfArray(arr)) {
				err = true;
				printArray(arr);
				break;
			}
		}
		System.out.println(err ? "Oops..what a fuck!" : "today is a beautiful day^_^");
	}
}