（25）Go实现反向索引堆

普通堆（10）Go实现二叉堆-数组实现：https://www.jianshu.com/p/37bca5f2a6e9

为什么要有索引堆？
原因如下主要有以下两个：

1）如上图，对于一组数据来说，经过堆整理后，数据的大多数索引都发生了变化，之后如果还想改变数组内的值，会找不到对应的数据，除非去遍历数组，不过这样太消耗资源
2）如果这组数据中存储的是比较大的数据，如是1个10000字节长度的字符串，每次堆交换位置，也会消耗太大的资源。

解决这个问题的关键就是索引堆，如下图

解读：
1）indexex[]中存储的是data中数据的索引，每次在堆中堆数据进行对比，交换的不是data的数据，
而是data的索引，这样每次只交换索引，资源消耗小速度快；
2）reverse是indexes的反向索引，即查找表，每次要改变data[i]的值，可通过reverse[i]找到
对应indexes的索引

最小反向查找索引堆的实现
// 最小索引堆,从1开始
type minIndexHeap struct {
	Size    int
	Indexes []int
	Data    []int
	Reverse []int
}

func NewMinIndexHeap(capacity int) *minIndexHeap {
	return &minIndexHeap{
		Indexes: make([]int, capacity+1),
		Data:    make([]int, capacity+1),
		Reverse: make([]int, capacity+1),
	}
}

func parent(i int) int {
	if i == 1 {
		return 1
	}
	return i / 2
}

func leftChild(i int) int {
	return 2 * i
}

// 查看data[i]是否存在堆中
func (h *minIndexHeap) Contain(i int) bool {
	// 索引超出范围,或者data[i]不存在堆中
	if i < 1 || i >= len(h.Reverse) || h.Reverse[i] == 0 {
		return false
	}
	return true
}

func (h *minIndexHeap) GetSize() int {
	return h.Size
}

func (h *minIndexHeap) IsEmpty() bool {
	return h.Size == 0
}

func (h *minIndexHeap) GetMin() (int, error) {
	if h.IsEmpty() {
		return 0, errors.New(
			"failed to getMin,heap is empty")
	}
	return h.Data[h.Indexes[1]], nil
}

// 上浮
func (h *minIndexHeap) shiftUp(childI int) {
	parI := parent(childI)
	// 1 <= parI <= childI <= h.size
	for h.Data[h.Indexes[parI]] > h.Data[h.Indexes[childI]] {
		h.Indexes[parI], h.Indexes[childI] = h.Indexes[childI], h.Indexes[parI]
		h.Reverse[h.Indexes[parI]], h.Reverse[h.Indexes[childI]] = parI, childI
		childI = parI
		parI = parent(parI)
	}
}

// 下沉 左闭右闭
func (h *minIndexHeap) shiftDown(parI int) {
	for {
		var minI int
		leftI := leftChild(parI)
		switch {
		// 左索引超出size
		case leftI > h.Size:
			return
			// 左索引不超,右索引超出size,说明左索引是最后索引
		case leftI+1 > h.Size:
			if h.Data[h.Indexes[parI]] > h.Data[h.Indexes[leftI]] {
			h.Indexes[parI], h.Indexes[leftI] = h.Indexes[leftI], h.Indexes[parI]

			h.Reverse[h.Indexes[parI]], h.Reverse[h.Indexes[leftI]] = parI, leftI
			}
			return
			// 跟左右中小的做比较
		case h.Data[h.Indexes[leftI]] <= h.Data[h.Indexes[leftI+1]]:
			minI = leftI
		default: // h.data[h.index[leftI]] > h.data[h.index[leftI+1]]
			minI = leftI + 1
		}

		// 比左右子节点的值都小,返回
		if h.Data[h.Indexes[parI]] < h.Data[h.Indexes[minI]] {
			return
		}

		h.Indexes[parI], h.Indexes[minI] = h.Indexes[minI], h.Indexes[parI]
		h.Reverse[h.Indexes[parI]], h.Reverse[h.Indexes[minI]] = parI, minI
		parI = minI
	}
}

// 插入元素
func (h *minIndexHeap) InsertItem(item int) error {
	// 从索引1开始,capacity=10,则len(data)=11
	if h.Size >= len(h.Data) {
		fmt.Println("failed to insertItem,heap is full.")
		return errors.New("heap is full.")
	}

	h.Size++
	// ==0则说明之前这个位置没插入过元素
	if h.Indexes[h.Size] == 0 {
		h.Indexes[h.Size] = h.Size
	}

	h.Data[h.Indexes[h.Size]] = item
	h.Reverse[h.Indexes[h.Size]] = h.Size

	childI := h.Size
	h.shiftUp(childI)

	return nil
}

// 取出元素
func (h *minIndexHeap) ExtractMin() (int, error) {
	if h.IsEmpty() {
		return 0, errors.New(
			"failed to getMax,heap is empty")
	}
	retVal := h.Data[h.Indexes[1]]

	h.Data[h.Indexes[1]], h.Data[h.Indexes[h.Size]] =
		h.Data[h.Indexes[h.Size]], 0

		// index从1开始存数据,索引0表示不存在,被删除
	h.Reverse[h.Indexes[h.Size]] = 0

	h.Size--
	h.shiftDown(1)
	return retVal, nil
}

// 改变指定data[i]的值
func (h *minIndexHeap) Change(i, newItem int) error {
	if h.IsEmpty() {
		return errors.New(
			"failed to change,heap is empty")
	}

	// 索引超出范围,或者i对应的索引不存在
	if !h.Contain(i) {
		return errors.New(
			"failed to change ,index is illegal")
	}

	// 能到这步说明索引存在且合法
	if h.Data[i] > newItem {
		h.Data[i] = newItem
		h.shiftUp(h.Reverse[i])
	} else if h.Data[i] < newItem {
		h.Data[i] = newItem
		h.shiftDown(h.Reverse[i])
	}

	return nil
}

// 打印二叉堆
func (h *minIndexHeap) Print() {
	count := 1
	j := 2
	var k uint = 1
	i := 1
	for i <= h.Size {
		fmt.Printf("%d层: ", k)
		for count < j {
			fmt.Printf(" %v ", h.Data[h.Indexes[i]])
			count++
			i++
			if i > h.Size {
				break
			}
		}
		fmt.Println()
		count = 0
		j = 1 << k
		k++
	}
}

测试
func main() {
	a := indexminheap1.NewMinIndexHeap(10)

	for i := 0; i < 8; i++ {
		a.InsertItem(rand.Intn(50) + 10)
	}
	fmt.Println("初始值:")
	a.Print()
	fmt.Println("=========")

	for i := 0; i < 3; i++ {
		a.ExtractMin()
	}
	fmt.Println("取出3个值:")
	a.Print()
	fmt.Println("=========")

	for i := 0; i < 4; i++ {
		a.InsertItem(rand.Intn(50) + 51)

	}
	fmt.Println("添加4个值:")
	a.Print()
	fmt.Println(*a)
	fmt.Println("=========")

	err := a.Change(4, 9)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("索引4改为9:")
	a.Print()
	fmt.Println(*a)
	fmt.Println("=========")

	fmt.Println("索引2改为510:")
	err = a.Change(2, 510)
	if err != nil {
		fmt.Println(err)
		return
	}
	a.Print()
	fmt.Println(*a)
}

测试结果 //
初始值:
1层:  19 
2层:  41  28 
3层:  47  41  57  35 
4层:  50 
=========
取出3个值:
1层:  41 
2层:  41  50 
3层:  47  57 
=========
添加4个值:
1层:  41 
2层:  41  50 
3层:  47  57  57  51 
4层:  95  62 
{9 [0 1 5 6 2 7 3 4 8 9 0] [0 41 47 57 51 41 50 57 95 62 0] [0 1 4 6 7 2 3 5 8 9 0]}
=========
索引4改为9:
1层:  9 
2层:  41  41 
3层:  47  57  57  50 
4层:  95  62 
{9 [0 4 5 1 2 7 3 6 8 9 0] [0 41 47 57 9 41 50 57 95 62 0] [0 3 4 6 1 2 7 5 8 9 0]}
=========
索引2改为510:
1层:  9 
2层:  41  41 
3层:  62  57  57  50 
4层:  95  510 
{9 [0 4 5 1 9 7 3 6 8 2 0] [0 41 510 57 9 41 50 57 95 62 0] [0 3 9 6 1 2 7 5 8 4 0]}

总结：代码的难度在于维护好indexes，data，reverse这个3个表的关系。//
比如（1）先添加5个元素，取出2个元素，再添加3个元素，这种情况要处理好indexes表。
网上很多代码在（1）这种情况会有堆中数据不准确的bug。
我的思路是：都从索引1开始，0表示不存在，在取出操作中，reverse[i]=0表示该节点不存在，
indexes[i]中的值不变，在下次重新添加到这一步时，把值更新到data[indexes[i]]中，如果
indexes[i]=0，令indexes[i]=size，即当前data[i]的索引