数据结构--堆的实现（Go）

参考文档

谢谢这两位博主，两位博主写的很好，我看了很久，自己总结的记录如下。

堆 堆排序 优先队列 图文详解（Golang实现）
最大堆，最小堆实现

堆

我们经常需要从一组对象中查找前N大值或小值。当然我们可以每次都先排序，然后再进行查找，但是这种做法效率很低。那么有没有一种特殊的数据结构，可以高效率的实现我们的需求呢，答案就是堆(heap)。Delete的复杂度为O(1)，Insert不大于树的高度。

介绍

1. 堆的最小值或最大值在根节点上，所以可以快速找到最大值或最小值。
2. 堆是一棵完全二叉树，所以我们可以用顺序结构来存储它，用一个数组表示，不需要指针，所以效率更高。
3. 当用数组表示时，数组中任一位置i上的元素，其左儿子（如果存在）在位置2i上，右儿子（如果存在）在位置(2i + 1)上，其父节点在位置(i/2)上。

实现（Go）

我的目录

堆实现代码（我是小白，求指导）

package heap

import (
	"fmt"
	"math"
)

//二叉堆是一种特殊的堆，它满足两个性质：结构性和堆序性
//结构性：二叉堆是一颗完全二叉树，完全二叉树可以用一个数组表示，不需要指针，所以效率更高。
//堆序性质：堆的最小值或最大值在根节点上，所以可以快速找到最大值或最小值。
//当用数组表示时，数组中任一位置i上的元素，其左儿子在位置2i上，右儿子在位置(2i+ 1)上，其父节点在位置(i/2)上。

type Interface interface {
	Len(heap *MaxHeap) int
	swap(i, j int)
	Bigger(i, j int) bool
	Insert(value int)
	Delete()
}

//Define MaxHeap
type MaxHeap struct {
	Element []int
}

// New a Heap
func NewHeap() *MaxHeap {
	//math.MinInt64 --> Integer limit values.
	return &MaxHeap{Element: []int{math.MaxInt64}}
}

// Implementing Methods
func (heap *MaxHeap) Len(i, j int) int {
	return len(heap.Element) - 1
}

func (heap *MaxHeap) Swap(i, j int) {
	heap.Element[i], heap.Element[j] = heap.Element[j], heap.Element[i]
}

func (heap *MaxHeap) Bigger(i, j int) bool {
	return heap.Element[i] > heap.Element[j]
}

func (heap *MaxHeap) Insert(value int) {
	heap.Element = append(heap.Element, value)
	i := len(heap.Element) - 1
	//上浮
	for ; heap.Bigger(i, i/2); i /= 2 {
		heap.Swap(i, i/2)
	}
}

func (heap *MaxHeap) Delete() {
	if len(heap.Element) == 1 {
		fmt.Println("empty heap")
		return
	}
	heap.Element[1] = heap.Element[len(heap.Element)-1]
	heap.Element = heap.Element[:len(heap.Element)-1]

	i := 1
	//Assuming
	MaxPos := i
	// If 2i and 2i + 1 exist , find MaxPos of (heap.Element[i], heap.Element[2i], heap.Element[2i+1])
	// and swap(i, MaxPos)
	for {
		// Find MaxPos
		if 2*i+1 <= len(heap.Element)-1 && heap.Bigger(2*i+1, i) {
			MaxPos = 2*i + 1
		}
		if 2*i <= len(heap.Element)-1 && heap.Element[MaxPos] < heap.Element[2*i] {
			MaxPos = 2 * i
		}
		//判断是否进行交换
		if MaxPos == i {
			return
		} else {
			heap.Swap(i, MaxPos)
			i = MaxPos
		}
	}
}

主函数（我是小白，求评论指导）

package main

import (
	"fmt"
	"github.com/iceriverdog/hellogo/Heap/heap"
)

func main() {
	h := heap.NewHeap()

	arr := []int{8, 1, 4, 5, 2}
	for _, v := range arr {
		h.Insert(v)
	}

	fmt.Println(h.Element)
	h.Delete()
	fmt.Println(h.Element)
	h.Delete()
	fmt.Println(h.Element)
	h.Delete()
	fmt.Println(h.Element)
	h.Delete()
	fmt.Println(h.Element)
	h.Delete()
	fmt.Println(h.Element)
}

希望大家评论指导我！ 谢谢 ！