（12）Go实现的最小堆求前m个高频数字

算法思路：
（1）创建map[int]int，k为数值中元素，v表示出现的次数，用map去重；
（2）维护一个K个节点的最小堆，堆中存储k，v；
（3）遍历map取出k，v，若v大于堆中最小v，则替换堆中最小的k，v；
（4）之后取出堆中的k，则为前m个高频数字

最小二叉堆的实现：
type minHeap struct {
	size int
	nums [][2]int
}

func NewMinHeapTree() *minHeap {
	return &minHeap{}
}

func Parent(i int) int {
	if i == 0 {
		return 0
	}
	return (i - 1) / 2
}

func LeftChild(i int) int {
	return 2*i + 1
}

func (heap *minHeap) IsEmpty() bool {
	return heap.size == 0
}

func (heap *minHeap) GetSize() int {
	return heap.size
}

func (heap *minHeap) GetMinVal() ([2]int, error) {
	if heap.IsEmpty() {
		return [2]int{}, errors.New(
			"failed to geiMinVal,minHeap is empty.")
	}
	return heap.nums[0], nil
}

func siftDown(heap *minHeap, parI int) {
	var minI int
	for {
		leftI := LeftChild(parI)
		switch {
		case leftI+1 > heap.size:
			return
		case leftI+2 > heap.size:
			if heap.nums[parI][1] > heap.nums[leftI][1] {
				heap.nums[parI], heap.nums[leftI] = heap.nums[leftI],
					heap.nums[parI]
			}
			return
		case heap.nums[leftI][1] <= heap.nums[leftI+1][1]:
			minI = leftI
		case heap.nums[leftI][1] > heap.nums[leftI+1][1]:
			minI = leftI + 1
		}

		if heap.nums[parI][1] > heap.nums[minI][1] {
			heap.nums[parI], heap.nums[minI] = heap.nums[minI],
				heap.nums[parI]
		}
		parI = minI
	}
}

func (heap *minHeap) SiftUp(key, val int) {
	heap.nums = append(heap.nums, [2]int{key, val})
	parI := Parent(heap.size)
	childI := heap.size

	for heap.nums[parI][1] > heap.nums[childI][1] {
		heap.nums[parI], heap.nums[childI] = heap.nums[childI],
			heap.nums[parI]
		childI = parI
		parI = Parent(parI)
	}
	heap.size++
}

func (heap *minHeap) SiftDown() ([2]int, error) {
	minVal, err := heap.GetMinVal()
	if err != nil {
		return minVal, err
	}

	heap.size--
	heap.nums[0], heap.nums[heap.size] = heap.nums[heap.size], [2]int{}

	siftDown(heap, 0)
	return minVal, nil
}

func (heap *minHeap) Replace(key, val int) ([2]int, error) {
	minVal, err := heap.GetMinVal()
	if err != nil {
		return minVal, err
	}
	heap.nums[0] = [2]int{key, val}

	siftDown(heap, 0)
	return minVal, nil
}

前m个高频数字的实现：
func topKFrequent(nums []int, k int) []int {
	h := NewMinHeapTree()
	m := make(map[int]int)
	for _, v := range nums {
		m[v]++
	}

	count := 0
	minVal := [2]int{}
	minV := 0
	for v1, v2 := range m {
		if count == k {
			if v2 > minV {
				h.Replace(v1, v2)
				minVal, _ = h.GetMinVal()
				minV = minVal[1]
			}
			continue
		}
		h.SiftUp(v1, v2)
		count++
		if count == k {
			minVal, _ = h.GetMinVal()
			minV = minVal[1]
		}
	}

	buf := []int{}
	for i := 0; i < k; i++ {
		v, _ := h.SiftDown()
		buf = append(buf, v[0])
	}
	return buf
}

通过，逻辑正确。

解决方法2，不用最小堆，速度或许更快点，参考leetcode上的最优解：
// 代码如下
func topKFrequent(nums []int, k int) []int {
	arr := make([]int, 0)
	if len(nums) == 0 {
		return arr
	}
	m := make(map[int]int)
	maxCount := 0
	for _, v := range nums {
		m[v] += 1
		if m[v] > maxCount {
			maxCount = m[v]
		}
	}
	tmp := make([][]int, maxCount+1)
	for k, v := range m {
		tmp[v] = append(tmp[v], k)
	}
	for i := maxCount; i >= 0; i-- {
		if len(tmp[i]) == 0 {
			continue
		}
		for _, v := range tmp[i] {
			arr = append(arr, v)
			if len(arr) == k {
				goto BREAK
			}
		}
	}
BREAK:
	return arr
}

相关问题：
求n个数字中前m个最大值：https://www.jianshu.com/p/29493ea46f7b