From 221fe44e6344ecafce798c800527740a0a59fc3d Mon Sep 17 00:00:00 2001 From: dudaodong Date: Wed, 29 Jun 2022 15:37:42 +0800 Subject: [PATCH] docs: add doc for MaxHeap --- docs/datastructure/heap.md | 367 +++++++++++++++++++++++++++++++++++++ 1 file changed, 367 insertions(+) create mode 100644 docs/datastructure/heap.md diff --git a/docs/datastructure/heap.md b/docs/datastructure/heap.md new file mode 100644 index 0000000..9bc0cbb --- /dev/null +++ b/docs/datastructure/heap.md @@ -0,0 +1,367 @@ +# Heap +Heap is a binary heap tree implemented by slice. + +
+ +## Source + +- [https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go](https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go) + + +
+ +## Usage +```go +import ( + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) +``` + +
+ +## Index + +- [MaxHeap](#MaxHeap) +- [Values](#Values) +- [Add](#Add) +- [Delete](#Delete) +- [Contain](#Contain) +- [ContainAll](#ContainAll) +- [Clone](#Clone) +- [Size](#Size) +- [Equal](#Equal) + + +
+ +## Documentation + +### 1. MaxHeap +MaxHeap is a binary heap tree implemented by slice, The key of the root node is both greater than or equal to the key value of the left subtree and greater than or equal to the key value of the right subtree. + +### NewMaxHeap +

Return a NewMaxHeap pointer instance.

+ +Signature: + +```go +type MaxHeap[T any] struct { + data []T + comparator lancetconstraints.Comparator +} +func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T] +``` +Example: + +```go +package main + +import ( + "fmt" + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) + +type intComparator struct{} + +func (c *intComparator) Compare(v1, v2 any) int { + val1, _ := v1.(int) + val2, _ := v2.(int) + + if val1 < val2 { + return -1 + } else if val1 > val2 { + return 1 + } + return 0 +} + +func main() { + maxHeap := heap.NewMaxHeap[int](&intComparator{}) + fmt.Println(maxHeap) +} +``` + + + + +### Push +

Push value into the heap

+ +Signature: + +```go +func (h *MaxHeap[T]) Push(value T) +``` +Example: + +```go +package main + +import ( + "fmt" + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) + +type intComparator struct{} + +func (c *intComparator) Compare(v1, v2 any) int { + val1, _ := v1.(int) + val2, _ := v2.(int) + + if val1 < val2 { + return -1 + } else if val1 > val2 { + return 1 + } + return 0 +} + +func main() { + maxHeap := heap.NewMaxHeap[int](&intComparator{}) + values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11} + + for _, v := range values { + maxHeap.Push(v) + } + + fmt.Println(maxHeap.Data()) //[]int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2} +} +``` + + + + +### Pop +

Pop return the largest value, and remove it from the heap if heap is empty, return zero value and fasle

+ +Signature: + +```go +func (h *MaxHeap[T]) Pop() (T, bool) +``` +Example: + +```go +package main + +import ( + "fmt" + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) + +type intComparator struct{} + +func (c *intComparator) Compare(v1, v2 any) int { + val1, _ := v1.(int) + val2, _ := v2.(int) + + if val1 < val2 { + return -1 + } else if val1 > val2 { + return 1 + } + return 0 +} + +func main() { + maxHeap := heap.NewMaxHeap[int](&intComparator{}) + values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11} + + for _, v := range values { + maxHeap.Push(v) + } + val, ok := maxHeap.Pop() + + fmt.Println(val) //12 + fmt.Println(ok) //true +} +``` + + + +### Peek +

Return the largest element from the heap without removing it, if heap is empty, it returns zero value and false.

+ +Signature: + +```go +func (h *MaxHeap[T]) Peek() (T, bool) +``` +Example: + +```go +package main + +import ( + "fmt" + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) + +type intComparator struct{} + +func (c *intComparator) Compare(v1, v2 any) int { + val1, _ := v1.(int) + val2, _ := v2.(int) + + if val1 < val2 { + return -1 + } else if val1 > val2 { + return 1 + } + return 0 +} + +func main() { + maxHeap := heap.NewMaxHeap[int](&intComparator{}) + values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11} + + for _, v := range values { + maxHeap.Push(v) + } + val, ok := maxHeap.Peek() + + fmt.Println(val) //12 + fmt.Println(maxHeap.Size()) //12 +} +``` + + + +### Data +

Return all element of the heap

+ +Signature: + +```go +func (h *MaxHeap[T]) Data() []T +``` +Example: + +```go +package main + +import ( + "fmt" + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) + +type intComparator struct{} + +func (c *intComparator) Compare(v1, v2 any) int { + val1, _ := v1.(int) + val2, _ := v2.(int) + + if val1 < val2 { + return -1 + } else if val1 > val2 { + return 1 + } + return 0 +} + +func main() { + maxHeap := heap.NewMaxHeap[int](&intComparator{}) + values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11} + + for _, v := range values { + maxHeap.Push(v) + } + + fmt.Println(maxHeap.Data()) //[]int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2} +} +``` + + +### Size +

Return the number of elements in the heap

+ +Signature: + +```go +func (h *MaxHeap[T]) Size() int +``` +Example: + +```go +package main + +import ( + "fmt" + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) + +type intComparator struct{} + +func (c *intComparator) Compare(v1, v2 any) int { + val1, _ := v1.(int) + val2, _ := v2.(int) + + if val1 < val2 { + return -1 + } else if val1 > val2 { + return 1 + } + return 0 +} + +func main() { + maxHeap := heap.NewMaxHeap[int](&intComparator{}) + values := []int{6, 5, 2} + + for _, v := range values { + maxHeap.Push(v) + } + + fmt.Println(maxHeap.Size()) //3 +} +``` + + + +### PrintStructure +

Print the tree structure of the heap

+ +Signature: + +```go +func (h *MaxHeap[T]) PrintStructure() +``` +Example: + +```go +package main + +import ( + "fmt" + heap "github.com/duke-git/lancet/v2/datastructure/heap" +) + +type intComparator struct{} + +func (c *intComparator) Compare(v1, v2 any) int { + val1, _ := v1.(int) + val2, _ := v2.(int) + + if val1 < val2 { + return -1 + } else if val1 > val2 { + return 1 + } + return 0 +} + +func main() { + maxHeap := heap.NewMaxHeap[int](&intComparator{}) + values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11} + + for _, v := range values { + maxHeap.Push(v) + } + + fmt.Println(maxHeap.PrintStructure()) +// 12 +// 9 11 +// 4 8 10 7 +// 1 3 5 6 2 +} +``` \ No newline at end of file