release v2.1.1

docs: add doc for heap datastructure
docs: update convertor package doc
2026-02-05 05:12:26 +08:00 · 2022-07-06 11:25:02 +08:00 · 2022-07-06 11:22:00 +08:00 · 2022-07-06 11:17:45 +08:00 · 2022-07-06 11:15:51 +08:00 · 2022-07-06 11:04:30 +08:00
14 changed files with 1226 additions and 10 deletions
--- a/README.md
+++ b/README.md
@@ -3,8 +3,8 @@

 <br/>

-![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-2.1.0-green.svg)](https://github.com/duke-git/lancet/releases)
+![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
+[![Release](https://img.shields.io/badge/release-2.1.1-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -118,8 +118,10 @@ import "github.com/duke-git/lancet/v2/convertor"
 - [ToBool](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToBool)
 - [ToBytes](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToBytes)
 - [ToChar](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToChar)
+- [ToFloat](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToFloat)
 - [ToInt](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToInt)
 - [ToJson](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToJson)
+- [ToPointer](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToPointer)
 - [ToString](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#ToString)
 - [StructToMap](https://github.com/duke-git/lancet/blob/main/docs/convertor.md#StructToMap)
  
@@ -213,6 +215,7 @@ import stack "github.com/duke-git/lancet/v2/datastructure/stack"
 import queue "github.com/duke-git/lancet/v2/datastructure/queue"
 import set "github.com/duke-git/lancet/v2/datastructure/set"
 import tree "github.com/duke-git/lancet/v2/datastructure/tree"
+import heap "github.com/duke-git/lancet/v2/datastructure/heap"
 ```
 #### Function list:
 - [List](https://github.com/duke-git/lancet/blob/main/docs/datastructure/list.md)
@@ -221,6 +224,7 @@ import tree "github.com/duke-git/lancet/v2/datastructure/tree"
 - [Queue](https://github.com/duke-git/lancet/blob/main/docs/datastructure/queue.md)
 - [Set](https://github.com/duke-git/lancet/blob/main/docs/datastructure/set.md)
 - [Tree](https://github.com/duke-git/lancet/blob/main/docs/datastructure/tree.md)
+- [Heap](https://github.com/duke-git/lancet/blob/main/docs/datastructure/heap.md)


 ### 7. Fileutil package implements some basic functions for file operations.
@@ -395,6 +399,8 @@ import "github.com/duke-git/lancet/v2/slice"
 - [Some](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Some)
 - [StringSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#StringSlice)
 - [SymmetricDifference](https://github.com/duke-git/lancet/blob/main/docs/slice.md#SymmetricDifference)
+- [ToSlice](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ToSlice)
+- [ToSlicePointer](https://github.com/duke-git/lancet/blob/main/docs/slice.md#ToSlicePointer)
 - [Unique](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Unique)
 - [UniqueBy](https://github.com/duke-git/lancet/blob/main/docs/slice.md#UniqueBy)
 - [Union](https://github.com/duke-git/lancet/blob/main/docs/slice.md#Union)
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -3,8 +3,8 @@

 <br/>

-![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-2.1.0-green.svg)](https://github.com/duke-git/lancet/releases)
+![Go version](https://img.shields.io/badge/go-%3E%3Dv1.18-9cf)
+[![Release](https://img.shields.io/badge/release-2.1.1-green.svg)](https://github.com/duke-git/lancet/releases)
 [![GoDoc](https://godoc.org/github.com/duke-git/lancet/v2?status.svg)](https://pkg.go.dev/github.com/duke-git/lancet/v2)
 [![Go Report Card](https://goreportcard.com/badge/github.com/duke-git/lancet/v2)](https://goreportcard.com/report/github.com/duke-git/lancet/v2)
 [![test](https://github.com/duke-git/lancet/actions/workflows/codecov.yml/badge.svg?branch=main&event=push)](https://github.com/duke-git/lancet/actions/workflows/codecov.yml)
@@ -117,8 +117,10 @@ import "github.com/duke-git/lancet/v2/convertor"
 - [ToBool](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToBool)
 - [ToBytes](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToBytes)
 - [ToChar](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToChar)
+- [ToFloat](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToFloat)
 - [ToInt](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToInt)
 - [ToJson](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToJson)
+- [ToPointer](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToPointer)
 - [ToString](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#ToString)
 - [StructToMap](https://github.com/duke-git/lancet/blob/main/docs/convertor_zh-CN.md#StructToMap)
  
@@ -211,6 +213,7 @@ import stack "github.com/duke-git/lancet/v2/datastructure/stack"
 import queue "github.com/duke-git/lancet/v2/datastructure/queue"
 import set "github.com/duke-git/lancet/v2/datastructure/set"
 import tree "github.com/duke-git/lancet/v2/datastructure/tree"
+import heap "github.com/duke-git/lancet/v2/datastructure/heap"
 ```
 #### Function list:
 - [List](https://github.com/duke-git/lancet/blob/main/docs/datastructure/list_zh-CN.md)
@@ -219,6 +222,7 @@ import tree "github.com/duke-git/lancet/v2/datastructure/tree"
 - [Queue](https://github.com/duke-git/lancet/blob/main/docs/datastructure/queue_zh-CN.md)
 - [Set](https://github.com/duke-git/lancet/blob/main/docs/datastructure/set_zh-CN.md)
 - [Tree](https://github.com/duke-git/lancet/blob/main/docs/datastructure/tree_zh-CN.md)
+- [Heap](https://github.com/duke-git/lancet/blob/main/docs/datastructure/heap.md)


 ### 7. fileutil包支持文件基本操作。
@@ -390,6 +394,8 @@ import "github.com/duke-git/lancet/v2/slice"
 - [Some](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Some)
 - [StringSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#StringSlice)
 - [SymmetricDifference](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#SymmetricDifference)
+- [ToSlice](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ToSlice)
+- [ToSlicePointer](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#ToSlicePointer)
 - [Unique](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Unique)
 - [UniqueBy](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#UniqueBy)
 - [Union](https://github.com/duke-git/lancet/blob/main/docs/slice_zh-CN.md#Union)
--- a/convertor/convertor.go
+++ b/convertor/convertor.go
@@ -170,6 +170,11 @@ func ToInt(value any) (int64, error) {
 	}
 }

+// ToPointer returns a pointer to this value
+func ToPointer[T any](value T) *T {
+	return &value
+}
+
 // StructToMap convert struct to map, only convert exported struct field
 // map key is specified same as struct field tag `json` value
 func StructToMap(value any) (map[string]any, error) {
--- a/convertor/convertor_test.go
+++ b/convertor/convertor_test.go
@@ -178,3 +178,10 @@ func TestColorRGBToHex(t *testing.T) {
 	assert := internal.NewAssert(t, "TestColorRGBToHex")
 	assert.Equal(expected, colorHex)
 }
+
+func TestToPointer(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToPointer")
+	result := ToPointer(123)
+
+	assert.Equal(*result, 123)
+}
--- a/datastructure/heap/maxheap.go
+++ b/datastructure/heap/maxheap.go
@@ -0,0 +1,189 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package datastructure implements some data structure. eg. list, linklist, stack, queue, tree, graph.
+package datastructure
+
+import (
+	"fmt"
+
+	"github.com/duke-git/lancet/v2/lancetconstraints"
+)
+
+// MaxHeap implements a binary max heap
+// type T should implements Compare function in lancetconstraints.Comparator interface.
+type MaxHeap[T any] struct {
+	data       []T
+	comparator lancetconstraints.Comparator
+}
+
+// NewMaxHeap returns a MaxHeap instance with the given comparator.
+func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T] {
+	return &MaxHeap[T]{
+		data:       make([]T, 0),
+		comparator: comparator,
+	}
+}
+
+// Push value into the heap
+func (h *MaxHeap[T]) Push(value T) {
+	h.data = append(h.data, value)
+	h.heapifyUp(len(h.data) - 1)
+}
+
+// heapifyUp heapify the data from bottom to top
+func (h *MaxHeap[T]) heapifyUp(i int) {
+	for h.comparator.Compare(h.data[parentIndex(i)], h.data[i]) < 0 {
+		h.swap(parentIndex(i), i)
+		i = parentIndex(i)
+	}
+}
+
+// Pop return the largest value, and remove it from the heap
+// if heap is empty, return zero value and fasle
+func (h *MaxHeap[T]) Pop() (T, bool) {
+	var val T
+	if h.Size() == 0 {
+		return val, false
+	}
+
+	val = h.data[0]
+	l := len(h.data) - 1
+
+	h.data[0] = h.data[l]
+	h.data = h.data[:l]
+	h.heapifyDown(0)
+
+	return val, true
+}
+
+// heapifyDown heapify the data from top to bottom
+func (h *MaxHeap[T]) heapifyDown(i int) {
+	lastIndex := len(h.data) - 1
+	l, r := leftChildIndex(i), rightChildIndex(i)
+	childToCompare := 0
+
+	for l <= lastIndex {
+		if l == lastIndex {
+			childToCompare = l
+		} else if h.comparator.Compare(h.data[l], h.data[r]) > 0 {
+			childToCompare = l
+		} else {
+			childToCompare = r
+		}
+
+		if h.comparator.Compare(h.data[i], h.data[childToCompare]) < 0 {
+			h.swap(i, childToCompare)
+			i = childToCompare
+			l, r = leftChildIndex(i), rightChildIndex(i)
+		} else {
+			break
+		}
+	}
+}
+
+// Peek returns the largest element from the heap without removing it.
+// if heap is empty, it returns zero value and false.
+func (h *MaxHeap[T]) Peek() (T, bool) {
+	if h.Size() == 0 {
+		var val T
+		return val, false
+	}
+
+	return h.data[0], true
+}
+
+// Size return the number of elements in the heap
+func (h *MaxHeap[T]) Size() int {
+	return len(h.data)
+}
+
+// Data return data of the heap
+func (h *MaxHeap[T]) Data() []T {
+	return h.data
+}
+
+// PrintStructure print the structure of the heap
+func (h *MaxHeap[T]) PrintStructure() {
+	level := 1
+	data := h.data
+	length := len(h.data)
+	index := 0
+
+	list := [][]string{}
+	temp := []string{}
+	for index < length {
+		start := powerTwo(level-1) - 1
+		end := start + powerTwo(level-1) - 1
+
+		temp = append(temp, fmt.Sprintf("%v", data[index]))
+		index++
+
+		if index > end || index >= length {
+			list = append(list, temp)
+			temp = []string{}
+
+			if index < length {
+				level++
+			}
+		}
+	}
+
+	lastNum := powerTwo(level - 1)
+	lastLen := lastNum + (lastNum - 1)
+
+	heapTree := make([][]string, level, level)
+	for i := 0; i < level; i++ {
+		heapTree[i] = make([]string, lastLen, lastLen)
+		for j := 0; j < lastLen; j++ {
+			heapTree[i][j] = ""
+		}
+	}
+
+	for k := 0; k < len(list); k++ {
+		vals := list[k]
+		tempLevel := level - k
+		st := powerTwo(tempLevel-1) - 1
+		for _, v := range vals {
+			heapTree[k][st] = v
+			gap := powerTwo(tempLevel)
+			st = st + gap
+		}
+	}
+
+	for m := 0; m < level; m++ {
+		for n := 0; n < lastLen; n++ {
+			val := heapTree[m][n]
+			if val == "" {
+				fmt.Printf(" ")
+			} else {
+				fmt.Printf(val)
+			}
+		}
+		fmt.Println()
+	}
+}
+
+// parentIndex get parent index of the given index
+func parentIndex(i int) int {
+	return (i - 1) / 2
+}
+
+// leftChildIndex get left child index of the given index
+func leftChildIndex(i int) int {
+	return 2*i + 1
+}
+
+// rightChildIndex get right child index of the given index
+func rightChildIndex(i int) int {
+	return 2*i + 2
+}
+
+// swap two elements in the heap
+func (h *MaxHeap[T]) swap(i, j int) {
+	h.data[i], h.data[j] = h.data[j], h.data[i]
+}
+
+func powerTwo(n int) int {
+	return 1 << n
+}
--- a/datastructure/heap/maxheap_test.go
+++ b/datastructure/heap/maxheap_test.go
@@ -0,0 +1,78 @@
+package datastructure
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/v2/internal"
+)
+
+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 TestMaxHeap_Push(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMaxHeap_Push")
+
+	heap := NewMaxHeap[int](&intComparator{})
+	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+
+	for _, v := range values {
+		heap.Push(v)
+	}
+
+	expected := []int{12, 9, 11, 4, 8, 10, 7, 1, 3, 5, 6, 2}
+	assert.Equal(expected, heap.data)
+
+	assert.Equal(12, heap.Size())
+
+	heap.PrintStructure()
+}
+
+func TestMaxHeap_Pop(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMaxHeap_Pop")
+
+	heap := NewMaxHeap[int](&intComparator{})
+
+	_, ok := heap.Pop()
+	assert.Equal(false, ok)
+
+	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+	for _, v := range values {
+		heap.Push(v)
+	}
+
+	val, ok := heap.Pop()
+	assert.Equal(12, val)
+	assert.Equal(true, ok)
+	assert.Equal(11, heap.Size())
+}
+
+func TestMaxHeap_Peek(t *testing.T) {
+	assert := internal.NewAssert(t, "TestMaxHeap_Peek")
+
+	heap := NewMaxHeap[int](&intComparator{})
+
+	_, ok := heap.Peek()
+	assert.Equal(false, ok)
+
+	values := []int{6, 5, 2, 4, 7, 10, 12, 1, 3, 8, 9, 11}
+	for _, v := range values {
+		heap.Push(v)
+	}
+
+	val, ok := heap.Peek()
+	assert.Equal(12, val)
+	assert.Equal(true, ok)
+
+	assert.Equal(12, heap.Size())
+}
--- a/docs/convertor.md
+++ b/docs/convertor.md
@@ -24,8 +24,11 @@ import (
 - [ToBool](#ToBool)
 - [ToBytes](#ToBytes)
 - [ToChar](#ToChar)
+
+- [ToFloat](#ToFloat)
 - [ToInt](#ToInt)
 - [ToJson](#ToJson)
+- [ToPointer](#ToPointer)
 - [ToString](#ToString)
 - [StructToMap](#StructToMap)

@@ -286,14 +289,14 @@ func main() {



-### <span id="ToString">ToString</span>
+### <span id="ToJson">ToJson</span>

-<p>Convert interface to string. </p>
+<p>Convert interface to json string. If param can't be converted, will return "" and error. </p>

 <b>Signature:</b>

 ```go
-func ToString(value any) string
+func ToJson(value any) (string, error)
 ```
 <b>Example:</b>

@@ -306,9 +309,36 @@ import (
 )

 func main() {
-    fmt.Printf("%q", convertor.ToString(1)) //"1"
-    fmt.Printf("%q", convertor.ToString(1.1)) //"1.1"
-    fmt.Printf("%q", convertor.ToString([]int{1, 2, 3})) //"[1,2,3]"
+    var aMap = map[string]int{"a": 1, "b": 2, "c": 3}
+    jsonStr, _ := convertor.ToJson(aMap)
+    fmt.Printf("%q", jsonStr) //"{\"a\":1,\"b\":2,\"c\":3}"
+}
+```
+
+
+
+### <span id="ToPointer">ToPointer</span>
+
+<p>Returns a pointer to passed value. </p>
+
+<b>Signature:</b>
+
+```go
+func ToPointer[T any](value T) *T
+```
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    result := convertor.ToPointer(123)
+    fmt.Println(*result) //123
 }
 ```

--- a/docs/convertor_zh-CN.md
+++ b/docs/convertor_zh-CN.md
@@ -26,8 +26,11 @@ import (
 - [ToBool](#ToBool)
 - [ToBytes](#ToBytes)
 - [ToChar](#ToChar)
+
+- [ToFloat](#ToFloat)
 - [ToInt](#ToInt)
 - [ToJson](#ToJson)
+- [ToPointer](#ToPointer)
 - [ToString](#ToString)
 - [StructToMap](#StructToMap)

@@ -288,6 +291,33 @@ func main() {



+### <span id="ToPointer">ToPointer</span>
+
+<p>返回传入值的指针</p>
+
+<b>函数签名:</b>
+
+```go
+func ToPointer[T any](value T) *T
+```
+<b>例子:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    result := convertor.ToPointer(123)
+    fmt.Println(*result) //123
+}
+```
+
+
+
 ### <span id="ToString">ToString</span>

 <p>将interface转成字符串</p>
--- a/docs/datastructure/heap.md
+++ b/docs/datastructure/heap.md
@@ -0,0 +1,364 @@
+# Heap
+Heap is a binary heap tree implemented by slice.
+
+<div STYLE="page-break-after: always;"></div>
+
+## 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)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage
+```go
+import (
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+- [MaxHeap](#MaxHeap)
+- [Push](#Push)
+- [Pop](#Pop)
+- [Peek](#Peek)
+- [Data](#Data)
+- [Size](#Size)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 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.
+
+### <span id="NewMaxHeap">NewMaxHeap</span>
+<p>Return a NewMaxHeap pointer instance.</p>
+
+<b>Signature:</b>
+
+```go
+type MaxHeap[T any] struct {
+	data       []T
+	comparator lancetconstraints.Comparator
+}
+func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
+```
+<b>Example:</b>
+
+```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)
+}
+```
+
+
+
+
+### <span id="Push">Push</span>
+<p>Push value into the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Push(value T)
+```
+<b>Example:</b>
+
+```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}
+}
+```
+
+
+
+
+### <span id="Pop">Pop</span>
+<p>Pop return the largest value, and remove it from the heap if heap is empty, return zero value and fasle</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Pop() (T, bool)
+```
+<b>Example:</b>
+
+```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
+}
+```
+
+
+
+### <span id="Peek">Peek</span>
+<p>Return the largest element from the heap without removing it, if heap is empty, it returns zero value and false.</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Peek() (T, bool)
+```
+<b>Example:</b>
+
+```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
+}
+```
+
+
+
+### <span id="Data">Data</span>
+<p>Return all element of the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Data() []T
+```
+<b>Example:</b>
+
+```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}
+}
+```
+
+
+### <span id="Size">Size</span>
+<p>Return the number of elements in the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) Size() int
+```
+<b>Example:</b>
+
+```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
+}
+```
+
+
+
+### <span id="PrintStructure">PrintStructure</span>
+<p>Print the tree structure of the heap</p>
+
+<b>Signature:</b>
+
+```go
+func (h *MaxHeap[T]) PrintStructure()
+```
+<b>Example:</b>
+
+```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
+}
+```
--- a/docs/datastructure/heap_zh-CN.md
+++ b/docs/datastructure/heap_zh-CN.md
@@ -0,0 +1,364 @@
+# Heap
+堆，切片实现的二叉堆数据结构。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码
+
+- [https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go](https://github.com/duke-git/lancet/blob/main/datastructure/heap/maxheap.go)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法
+```go
+import (
+    heap "github.com/duke-git/lancet/v2/datastructure/heap"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+- [MaxHeap](#MaxHeap)
+- [Push](#Push)
+- [Pop](#Pop)
+- [Peek](#Peek)
+- [Data](#Data)
+- [Size](#Size)
+
+
+<div STYLE="page-break-after: always;"></div>
+
+## API文档
+
+### 1. MaxHeap
+MaxHeap是通过slice实现的二叉堆树，根节点的key既大于等于左子树的key值且大于等于右子树的key值。
+
+### <span id="NewMaxHeap">NewMaxHeap</span>
+<p>返回NewMaxHeap指针实例</p>
+
+<b>函数签名:</b>
+
+```go
+type MaxHeap[T any] struct {
+	data       []T
+	comparator lancetconstraints.Comparator
+}
+func NewMaxHeap[T any](comparator lancetconstraints.Comparator) *MaxHeap[T]
+```
+<b>例子:</b>
+
+```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)
+}
+```
+
+
+
+
+### <span id="Push">Push</span>
+<p>向堆中插入数据</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Push(value T)
+```
+<b>例子:</b>
+
+```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}
+}
+```
+
+
+
+
+### <span id="Pop">Pop</span>
+<p>返回堆中最大值并将其从堆中删除，如果堆为空，返回零值并返回false</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Pop() (T, bool)
+```
+<b>例子:</b>
+
+```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
+}
+```
+
+
+
+### <span id="Peek">Peek</span>
+<p>返回堆中最大值，如果堆为空，返回零值并返回false</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Peek() (T, bool)
+```
+<b>例子:</b>
+
+```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
+}
+```
+
+
+
+### <span id="Data">Data</span>
+<p>返回堆中全部元素的切片</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Data() []T
+```
+<b>例子:</b>
+
+```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}
+}
+```
+
+
+### <span id="Size">Size</span>
+<p>返回堆中元素的数量</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) Size() int
+```
+<b>例子:</b>
+
+```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
+}
+```
+
+
+
+### <span id="PrintStructure">PrintStructure</span>
+<p>打印堆的树形结构</p>
+
+<b>函数签名:</b>
+
+```go
+func (h *MaxHeap[T]) PrintStructure()
+```
+<b>例子:</b>
+
+```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
+}
+```
--- a/docs/slice.md
+++ b/docs/slice.md
@@ -1063,6 +1063,55 @@ func main() {



+### <span id="ToSlice">ToSlice</span>
+<p>Returns a slices of a variable parameter transformation</p>
+
+<b>Signature:</b>
+
+```go
+func ToSlice[T any](value ...T) []T
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	res := slice.ToSlice("a", "b")
+	fmt.Println(res) //{"a", "b"}
+}
+```
+
+
+
+### <span id="ToSlicePointer">ToSlice</span>
+<p>Returns a pointer to the slices of a variable parameter transformation</p>
+
+<b>Signature:</b>
+
+```go
+func ToSlicePointer[T any](value ...T) []*T
+```
+<b>Example:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	str1 := "a"
+	str2 := "b"
+	res := slice.ToSlice(str1, str2)
+	fmt.Println(res) // res -> []*string{&str1, &str2}
+}
+```
+
+
 ### <span id="Unique">Unique</span>
 <p>Remove duplicate elements in slice.</p>

--- a/docs/slice_zh-CN.md
+++ b/docs/slice_zh-CN.md
@@ -56,6 +56,8 @@ import (
 - [Some](#Some)
 - [StringSlice](#StringSlice)
 - [SymmetricDifference](#SymmetricDifference)
+- [ToSlice](#ToSlice)
+- [ToSlicePointer](#ToSlicePointer)
 - [Unique](#Unique)
 - [UniqueBy](#UniqueBy)
 - [Union](#Union)
@@ -1062,6 +1064,56 @@ func main() {
 ```


+### <span id="ToSlice">ToSlice</span>
+<p>将可变参数转为切片</p>
+
+<b>函数签名:</b>
+
+```go
+func ToSlice[T any](value ...T) []T
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	res := slice.ToSlice("a", "b")
+	fmt.Println(res) //{"a", "b"}
+}
+```
+
+
+
+### <span id="ToSlicePointer">ToSlice</span>
+<p>将可变参数转为指针切片</p>
+
+<b>函数签名:</b>
+
+```go
+func ToSlicePointer[T any](value ...T) []*T
+```
+<b>例子:</b>
+
+```go
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	str1 := "a"
+	str2 := "b"
+	res := slice.ToSlice(str1, str2)
+	fmt.Println(res) // res -> []*string{&str1, &str2}
+}
+```
+
+
+
 ### <span id="Unique">Unique</span>
 <p>删除切片中的重复元素</p>

--- a/slice/slice.go
+++ b/slice/slice.go
@@ -803,3 +803,21 @@ func LastIndexOf[T any](slice []T, value T) int {

 	return -1
 }
+
+// ToSlicePointer returns a pointer to the slices of a variable parameter transformation
+func ToSlicePointer[T any](value ...T) []*T {
+	out := make([]*T, len(value))
+	for i := range value {
+		out[i] = &value[i]
+	}
+	return out
+}
+
+// ToSlice returns a slices of a variable parameter transformation
+func ToSlice[T any](value ...T) []T {
+	out := make([]T, len(value))
+	for i := range value {
+		out[i] = value[i]
+	}
+	return out
+}
--- a/slice/slice_test.go
+++ b/slice/slice_test.go
@@ -583,3 +583,21 @@ func TestLastIndexOf(t *testing.T) {
 	assert.Equal(1, LastIndexOf(arr, "a"))
 	assert.Equal(-1, LastIndexOf(arr, "d"))
 }
+
+func TestToSlice(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToSlice")
+
+	str1 := "a"
+	str2 := "b"
+	assert.Equal([]string{"a"}, ToSlice(str1))
+	assert.Equal([]string{"a", "b"}, ToSlice(str1, str2))
+}
+
+func TestToSlicePointer(t *testing.T) {
+	assert := internal.NewAssert(t, "TestToSlicePointer")
+
+	str1 := "a"
+	str2 := "b"
+	assert.Equal([]*string{&str1}, ToSlicePointer(str1))
+	assert.Equal([]*string{&str1, &str2}, ToSlicePointer(str1, str2))
+}
Author	SHA1	Message	Date
dudaodong	1faaf54986	release v2.1.1	2022-07-06 11:25:02 +08:00
dudaodong	efe1fba267	docs: add doc for heap datastructure	2022-07-06 11:22:00 +08:00
dudaodong	0c43cb3f68	docs: update convertor package doc	2022-07-06 11:17:45 +08:00
dudaodong	c25111e349	docs: add doc for ToSlice and ToSlicePointer function	2022-07-06 11:15:51 +08:00
dudaodong	a61ab5716e	docs: add doc for ToPointer function	2022-07-06 11:04:30 +08:00
dudaodong	628404dc7f	fix: fix lint error	2022-07-06 10:57:45 +08:00
tangqiu0205	bab0a27e40	Add ToPointer,ToSlicePointer,ToSlice func (#36 ) * Add ToPointer func * Add ToSlice and ToSlicePointer func Co-authored-by: zhanghu <305835360@qq.com>	2022-07-05 19:15:54 +08:00
dudaodong	fc0e104591	Merge branch 'main' into v2	2022-06-30 14:12:54 +08:00
dudaodong	e83e9a1651	docs: add doc for MaxHeap	2022-06-29 16:43:56 +08:00
dudaodong	3d2e6295c4	docs: add doc for MaxHeap	2022-06-29 15:40:14 +08:00
dudaodong	221fe44e63	docs: add doc for MaxHeap	2022-06-29 15:37:42 +08:00
dudaodong	7930f517ae	feat: add MaxHeap func PrintStructure	2022-06-29 11:08:07 +08:00
dudaodong	0f61321d5b	test: add unit test for MaxHeap	2022-06-27 17:55:35 +08:00
dudaodong	7ddeeb51e5	feat: add MaxHeap	2022-06-27 17:01:17 +08:00
dudaodong	484d2845b3	feat: add MaxHeap	2022-06-27 16:27:34 +08:00
dudaodong	bbbc6b6941	docs: update go version badge	2022-06-24 09:39:38 +08:00