[Leetcode]22. 数据流中的中位数

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

例如，

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

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

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

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

示例 1：

输入：
["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]
[[],[1],[2],[],[3],[]]
输出：[null,null,null,1.50000,null,2.00000]

示例 2：

输入：
["MedianFinder","addNum","findMedian","addNum","findMedian"]
[[],[2],[],[3],[]]
输出：[null,null,2.00000,null,2.50000]

思想：维护一个大根堆和一个小根堆，数据先进入小根堆，保持大根堆等于小根堆（偶数）或比小根堆少一个（奇数）。

这里的大根堆存放的是比较小的数，而小根堆则存放比较大的数，大根堆的堆顶和小根堆的堆顶是相邻的两个数，对其进行动态调整便可取到中位数。

如果大小根堆数量相等，那么送一个数据给根堆，如果新数据比小堆顶还要大，那么直接送入小根堆，否则先送入大根堆，再让大根堆调整后送入最大的数放到小根堆中。

如果小根堆比大根堆多一个，那么还是判断这个数是否比小堆顶大，大的话先送入小根堆再从小根堆送出一个最小的数给大根堆，否则直接送入大根堆。

type minHeap []int
type maxHeap []int

func (h minHeap) Len() int {
	return len(h)
}
func (h maxHeap) Len() int {
	return len(h)
}

func (h maxHeap) Less(i, j int) bool {
	return h[i] > h[j]
}
func (h minHeap) Less(i, j int) bool {
	return h[i] < h[j]
}

func (h maxHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}
func (h minHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}

func (h *minHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}
func (h *maxHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *maxHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func (h *minHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

type MedianFinder struct {
	maxH *maxHeap
	minH *minHeap
}

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

func (this *MedianFinder) AddNum(num int) {
	if this.minH.Len()==this.maxH.Len(){
		if this.minH.Len()==0||num>(*this.maxH)[0]{
			heap.Push(this.minH,num)
		}else{
			heap.Push(this.maxH,num)
			x := heap.Pop(this.maxH)
			heap.Push(this.minH,x)
		}
	}else {
		if num> (*this.minH)[0]{
			heap.Push(this.minH,num)
			x:=heap.Pop(this.minH)
			heap.Push(this.maxH,x)
		}else{
			heap.Push(this.maxH,num)
		}
	}
}

func (this *MedianFinder) FindMedian() float64 {
	if this.minH.Len()==this.maxH.Len(){
		return float64((*this.maxH)[0])/2.0 + float64((*this.minH)[0])/2.0
	}else{
		return float64((*this.minH)[0])
	}
}

题目来源：https://leetcode-cn.com/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof

标签：minH,return,22,int,中位数,根堆,maxH,func,Leetcode
来源： https://www.cnblogs.com/End1ess/p/15490693.html