release v2.0.4

README.md

@@ -4,7 +4,7 @@
 <br/>
 
 ![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-2.0.3-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.0.4-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)
@@ -35,9 +35,9 @@ English | [简体中文](./README_zh-CN.md)
 go get github.com/duke-git/lancet/v2 // will install latest version of v2.x.x
 ```
 
-2. <b>For users who use version below go1.18, you should install v1.x.x. now latest v1 is v1.2.7. </b>
+2. <b>For users who use version below go1.18, you should install v1.x.x. now latest v1 is v1.2.9. </b>
 ```go
-go get github.com/duke-git/lancet@v1.2.7 // below go1.18, install latest version of v1.x.x
+go get github.com/duke-git/lancet@v1.2.9 // below go1.18, install latest version of v1.x.x
 ```
 
 ## Usage

README_zh-CN.md

@@ -4,7 +4,7 @@
 <br/>
 
 ![Go version](https://img.shields.io/badge/go-%3E%3D1.16<recommend>-9cf)
-[![Release](https://img.shields.io/badge/release-2.0.3-green.svg)](https://github.com/duke-git/lancet/releases)
+[![Release](https://img.shields.io/badge/release-2.0.4-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)
@@ -35,9 +35,9 @@
 go get github.com/duke-git/lancet/v2 //安装v2最新版本v2.x.x
 ```
 
-2. <b>使用go1.18以下版本的用户，必须安装v1.x.x。目前最新的v1版本是v1.2.7。</b>
+2. <b>使用go1.18以下版本的用户，必须安装v1.x.x。目前最新的v1版本是v1.2.9。</b>
 ```go
-go get github.com/duke-git/lancet@v1.2.7 // 使用go1.18以下版本, 必须安装v1.x.x版本
+go get github.com/duke-git/lancet@v1.2.9 // 使用go1.18以下版本, 必须安装v1.x.x版本
 ```
 
 ## 用法

algorithm/sorter.go

@@ -7,7 +7,7 @@ package algorithm
 import "github.com/duke-git/lancet/v2/lancetconstraints"
 
 // BubbleSort use bubble to sort slice.
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
+func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
 		for j := 0; j < len(slice)-1-i; j++ {
 			isCurrGreatThanNext := comparator.Compare(slice[j], slice[j+1]) == 1
@@ -16,38 +16,26 @@ func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
 			}
 		}
 	}
-	return slice
 }
 
 // InsertionSort use insertion to sort slice.
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
-	size := len(slice)
-	if size <= 1 {
-		return slice
-	}
-
-	for i := 1; i < size; i++ {
-		currentItem := slice[i]
-		preIndex := i - 1
-		preItem := slice[preIndex]
-
-		isPreLessThanCurrent := comparator.Compare(preItem, currentItem) == -1
-		for preIndex >= 0 && isPreLessThanCurrent {
-			slice[preIndex+1] = slice[preIndex]
-			preIndex--
+func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	for i := 0; i < len(slice); i++ {
+		for j := i; j > 0; j-- {
+			isPreLessThanCurrent := comparator.Compare(slice[j], slice[j-1]) == -1
+			if isPreLessThanCurrent {
+				swap(slice, j, j-1)
+			} else {
+				break
+			}
 		}
-
-		slice[preIndex+1] = currentItem
 	}
-
-	return slice
 }
 
 // SelectionSort use selection to sort slice.
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
+func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	for i := 0; i < len(slice); i++ {
 		min := i
-
 		for j := i + 1; j < len(slice); j++ {
 			if comparator.Compare(slice[j], slice[min]) == -1 {
 				min = j
@@ -55,15 +43,11 @@ func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) []
 		}
 		swap(slice, i, min)
 	}
-	return slice
 }
 
 // ShellSort shell sort slice.
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
+func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	size := len(slice)
-	if size <= 1 {
-		return slice
-	}
 
 	gap := 1
 	for gap < size/3 {
@@ -76,21 +60,17 @@ func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
 				swap(slice, j, j-gap)
 			}
 		}
-		gap /= 3
+		gap = gap / 3
 	}
-
-	return slice
 }
 
 // QuickSort quick sorting for slice, lowIndex is 0 and highIndex is len(slice)-1
-func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T {
+func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
 	if lowIndex < highIndex {
 		p := partition(slice, lowIndex, highIndex, comparator)
 		QuickSort(slice, lowIndex, p-1, comparator)
 		QuickSort(slice, p+1, highIndex, comparator)
 	}
-
-	return slice
 }
 
 // partition split slice into two parts
@@ -110,7 +90,7 @@ func partition[T any](slice []T, lowIndex, highIndex int, comparator lancetconst
 }
 
 // HeapSort use heap to sort slice
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
+func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) {
 	size := len(slice)
 
 	for i := size/2 - 1; i >= 0; i-- {
@@ -120,8 +100,6 @@ func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) []T {
 		swap(slice, 0, j)
 		sift(slice, 0, j-1, comparator)
 	}
-
-	return slice
 }
 
 func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
@@ -145,15 +123,17 @@ func sift[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraint
 }
 
 // MergeSort merge sorting for slice
-func MergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T {
+func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator) {
+	mergeSort(slice, 0, len(slice)-1, comparator)
+}
+
+func mergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) {
 	if lowIndex < highIndex {
 		mid := (lowIndex + highIndex) / 2
-		MergeSort(slice, lowIndex, mid, comparator)
-		MergeSort(slice, mid+1, highIndex, comparator)
+		mergeSort(slice, lowIndex, mid, comparator)
+		mergeSort(slice, mid+1, highIndex, comparator)
 		merge(slice, lowIndex, mid, highIndex, comparator)
 	}
-
-	return slice
 }
 
 func merge[T any](slice []T, lowIndex, midIndex, highIndex int, comparator lancetconstraints.Comparator) {

algorithm/sorter_test.go

@@ -28,22 +28,15 @@ func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
 		return 1
 	}
 	return 0
-
-	//decending order
-	// if p1.Age > p2.Age {
-	// 	return -1
-	// } else if p1.Age < p2.Age {
-	// 	return 1
-	// }
 }
 
-var peoples = []people{
-	{Name: "a", Age: 20},
-	{Name: "b", Age: 10},
-	{Name: "c", Age: 17},
-	{Name: "d", Age: 8},
-	{Name: "e", Age: 28},
-}
+// var peoples = []people{
+// 	{Name: "a", Age: 20},
+// 	{Name: "b", Age: 10},
+// 	{Name: "c", Age: 17},
+// 	{Name: "d", Age: 8},
+// 	{Name: "e", Age: 28},
+// }
 
 type intComparator struct{}
 
@@ -60,40 +53,51 @@ func (c *intComparator) Compare(v1 any, v2 any) int {
 	return 0
 }
 
-var intSlice = []int{2, 1, 5, 3, 6, 4}
+// var intSlice = []int{2, 1, 5, 3, 6, 4}
 
 func TestBubbleSortForStructSlice(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestBubbleSortForStructSlice")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := BubbleSort(peoples, comparator)
-	t.Log(sortedPeopleByAge)
+	BubbleSort(peoples, comparator)
 
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+	actual := fmt.Sprintf("%v", peoples)
 
 	asssert.Equal(expected, actual)
 }
 
 func TestBubbleSortForIntSlice(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestBubbleSortForIntSlice")
-
+	numbers := []int{2, 1, 5, 3, 6, 4}
 	comparator := &intComparator{}
-	sortedInt := BubbleSort(intSlice, comparator)
-	expected := []int{1, 2, 3, 4, 5, 6}
+	BubbleSort(numbers, comparator)
 
-	asssert.Equal(expected, sortedInt)
+	asssert.Equal([]int{1, 2, 3, 4, 5, 6}, numbers)
 }
 
 func TestInsertionSort(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestInsertionSort")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := InsertionSort(peoples, comparator)
-	t.Log(sortedPeopleByAge)
+	InsertionSort(peoples, comparator)
 
-	expected := "[{e 28} {a 20} {c 17} {b 10} {d 8}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
+	actual := fmt.Sprintf("%v", peoples)
 
 	asssert.Equal(expected, actual)
 }
@@ -101,12 +105,18 @@ func TestInsertionSort(t *testing.T) {
 func TestSelectionSort(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestSelectionSort")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := SelectionSort(peoples, comparator)
-	t.Log(sortedPeopleByAge)
+	SelectionSort(peoples, comparator)
 
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+	actual := fmt.Sprintf("%v", peoples)
 
 	asssert.Equal(expected, actual)
 }
@@ -114,12 +124,18 @@ func TestSelectionSort(t *testing.T) {
 func TestShellSort(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestShellSort")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := ShellSort(peoples, comparator)
-	t.Log(sortedPeopleByAge)
+	ShellSort(peoples, comparator)
 
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+	actual := fmt.Sprintf("%v", peoples)
 
 	asssert.Equal(expected, actual)
 }
@@ -127,12 +143,18 @@ func TestShellSort(t *testing.T) {
 func TestQuickSort(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestQuickSort")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := QuickSort(peoples, 0, len(peoples)-1, comparator)
-	t.Log(sortedPeopleByAge)
+	QuickSort(peoples, 0, len(peoples)-1, comparator)
 
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+	actual := fmt.Sprintf("%v", peoples)
 
 	asssert.Equal(expected, actual)
 }
@@ -140,12 +162,18 @@ func TestQuickSort(t *testing.T) {
 func TestHeapSort(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestHeapSort")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := HeapSort(peoples, comparator)
-	t.Log(sortedPeopleByAge)
+	HeapSort(peoples, comparator)
 
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+	actual := fmt.Sprintf("%v", peoples)
 
 	asssert.Equal(expected, actual)
 }
@@ -153,12 +181,18 @@ func TestHeapSort(t *testing.T) {
 func TestMergeSort(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestMergeSort")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
-	sortedPeopleByAge := MergeSort(peoples, 0, len(peoples)-1, comparator)
-	t.Log(sortedPeopleByAge)
+	MergeSort(peoples, comparator)
 
 	expected := "[{d 8} {b 10} {c 17} {a 20} {e 28}]"
-	actual := fmt.Sprintf("%v", sortedPeopleByAge)
+	actual := fmt.Sprintf("%v", peoples)
 
 	asssert.Equal(expected, actual)
 }
@@ -166,6 +200,13 @@ func TestMergeSort(t *testing.T) {
 func TestCountSort(t *testing.T) {
 	asssert := internal.NewAssert(t, "TestCountSort")
 
+	peoples := []people{
+		{Name: "a", Age: 20},
+		{Name: "b", Age: 10},
+		{Name: "c", Age: 17},
+		{Name: "d", Age: 8},
+		{Name: "e", Age: 28},
+	}
 	comparator := &peopleAgeComparator{}
 	sortedPeopleByAge := CountSort(peoples, comparator)
 	t.Log(sortedPeopleByAge)

datastructure/queue/arrayqueue.go

@@ -1,79 +1,101 @@
 package datastructure
 
 import (
-	"errors"
 	"fmt"
 	"reflect"
 )
 
 // ArrayQueue implements queue with slice
 type ArrayQueue[T any] struct {
-	data   []T
-	length int
+	items    []T
+	head     int
+	tail     int
+	capacity int
+	size     int
 }
 
-// NewArrayQueue return a empty ArrayQueue pointer
-func NewArrayQueue[T any](values ...T) *ArrayQueue[T] {
-	data := make([]T, len(values))
-	for i, v := range values {
-		data[i] = v
+func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
+	return &ArrayQueue[T]{
+		items:    make([]T, 0, capacity),
+		head:     0,
+		tail:     0,
+		capacity: capacity,
+		size:     0,
 	}
-	return &ArrayQueue[T]{data: data, length: len(values)}
 }
 
 // Data return queue data
 func (q *ArrayQueue[T]) Data() []T {
-	return q.data
+	items := []T{}
+	for i := q.head; i < q.tail; i++ {
+		items = append(items, q.items[i])
+	}
+	return items
 }
 
 // Size return length of queue data
 func (q *ArrayQueue[T]) Size() int {
-	return q.length
+	return q.size
 }
 
 // IsEmpty checks if queue is empty or not
 func (q *ArrayQueue[T]) IsEmpty() bool {
-	return q.length == 0
+	return q.size == 0
 }
 
 // Front return front value of queue
 func (q *ArrayQueue[T]) Front() T {
-	return q.data[0]
+	return q.items[0]
 }
 
 // Back return back value of queue
 func (q *ArrayQueue[T]) Back() T {
-	return q.data[q.length-1]
+	return q.items[q.size-1]
 }
 
 // EnQueue put element into queue
-func (q *ArrayQueue[T]) EnQueue(value T) {
-	q.data = append(q.data, value)
-	q.length++
+func (q *ArrayQueue[T]) Enqueue(item T) bool {
+	if q.head == 0 && q.tail == q.capacity {
+		return false
+	} else if q.head != 0 && q.tail == q.capacity {
+		for i := q.head; i < q.tail; i++ {
+			q.items[i-q.head] = q.items[i]
+		}
+		q.tail = q.tail - q.head
+		q.head = 0
+	}
+
+	q.items = append(q.items, item)
+	q.tail++
+	q.size++
+	return true
 }
 
 // DeQueue remove head element of queue and return it, if queue is empty, return nil and error
-func (q *ArrayQueue[T]) DeQueue() (*T, error) {
-	if q.IsEmpty() {
-		return nil, errors.New("queue is empty")
+func (q *ArrayQueue[T]) Dequeue() (T, bool) {
+	var item T
+	if q.head == q.tail {
+		return item, false
 	}
-
-	headItem := q.data[0]
-	q.data = q.data[1:]
-	q.length--
-
-	return &headItem, nil
+	item = q.items[q.head]
+	q.head++
+	q.size--
+	return item, true
 }
 
 // Clear the queue data
 func (q *ArrayQueue[T]) Clear() {
-	q.data = []T{}
-	q.length = 0
+	capacity := q.capacity
+	q.items = make([]T, 0, capacity)
+	q.head = 0
+	q.tail = 0
+	q.size = 0
+	q.capacity = capacity
 }
 
 // Contain checks if the value is in queue or not
 func (q *ArrayQueue[T]) Contain(value T) bool {
-	for _, v := range q.data {
+	for _, v := range q.items {
 		if reflect.DeepEqual(v, value) {
 			return true
 		}
@@ -84,8 +106,8 @@ func (q *ArrayQueue[T]) Contain(value T) bool {
 // Print queue data
 func (q *ArrayQueue[T]) Print() {
 	info := "["
-	for _, v := range q.data {
-		info += fmt.Sprintf("%+v, ", v)
+	for i := q.head; i < q.tail; i++ {
+		info += fmt.Sprintf("%+v, ", q.items[i])
 	}
 	info += "]"
 	fmt.Println(info)

datastructure/queue/arrayqueue_test.go

@@ -6,13 +6,13 @@ import (
 	"github.com/duke-git/lancet/v2/internal"
 )
 
-func TestArrayQueue_EnQueue(t *testing.T) {
-	assert := internal.NewAssert(t, "TestArrayQueue_EnQueue")
+func TestArrayQueue_Enqueue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
 
-	queue := NewArrayQueue[int]()
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
+	queue := NewArrayQueue[int](5)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 
 	expected := []int{1, 2, 3}
 	data := queue.Data()
@@ -24,26 +24,30 @@ func TestArrayQueue_EnQueue(t *testing.T) {
 	assert.Equal(3, size)
 }
 
-func TestArrayQueue_DeQueue(t *testing.T) {
-	assert := internal.NewAssert(t, "TestArrayQueue_DeQueue")
+func TestArrayQueue_Dequeue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestArrayQueue_Dequeue")
 
-	queue := NewArrayQueue(1, 2, 3)
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 
-	val, err := queue.DeQueue()
-	if err != nil {
-		t.Fail()
-	}
+	val, ok := queue.Dequeue()
+	assert.Equal(true, ok)
 
 	queue.Print()
-	assert.Equal(1, *val)
-
+	assert.Equal(1, val)
 	assert.Equal([]int{2, 3}, queue.Data())
 }
 
 func TestArrayQueue_Front(t *testing.T) {
 	assert := internal.NewAssert(t, "TestArrayQueue_Front")
 
-	queue := NewArrayQueue(1, 2, 3)
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
 	val := queue.Front()
 
 	queue.Print()
@@ -55,7 +59,11 @@ func TestArrayQueue_Front(t *testing.T) {
 func TestArrayQueue_Back(t *testing.T) {
 	assert := internal.NewAssert(t, "TestArrayQueue_Back")
 
-	queue := NewArrayQueue(1, 2, 3)
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+
 	val := queue.Back()
 
 	queue.Print()
@@ -67,7 +75,10 @@ func TestArrayQueue_Back(t *testing.T) {
 func TestArrayQueue_Contain(t *testing.T) {
 	assert := internal.NewAssert(t, "TestArrayQueue_Contain")
 
-	queue := NewArrayQueue(1, 2, 3)
+	queue := NewArrayQueue[int](4)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 
 	assert.Equal(true, queue.Contain(1))
 	assert.Equal(false, queue.Contain(4))
@@ -76,11 +87,12 @@ func TestArrayQueue_Contain(t *testing.T) {
 func TestArrayQueue_Clear(t *testing.T) {
 	assert := internal.NewAssert(t, "TestArrayQueue_Clear")
 
-	queue := NewArrayQueue[int]()
+	queue := NewArrayQueue[int](4)
+
 	assert.Equal(true, queue.IsEmpty())
 	assert.Equal(0, queue.Size())
 
-	queue.EnQueue(1)
+	queue.Enqueue(1)
 	assert.Equal(false, queue.IsEmpty())
 	assert.Equal(1, queue.Size())
 

docs/algorithm.md

@@ -21,18 +21,23 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## Index
-- [BubbleSort](#BubbleSort)
-- [CountSort](#CountSort)
-- [HeapSort](#HeapSort)
-- [InsertionSort](#InsertionSort)
-- [MergeSort](#MergeSort)
-- [QuickSort](#QuickSort)
-- [SelectionSort](#SelectionSort)
-- [ShellSort](#ShellSort)
-- [BinarySearch](#BinarySearch)
-- [BinaryIterativeSearch](#BinaryIterativeSearch)
-- [LinearSearch](#LinearSearch)
-- [LRUCache](#LRUCache)
+- [Algorithm](#algorithm)
+  - [Source](#source)
+  - [Usage](#usage)
+  - [Index](#index)
+  - [Documentation](#documentation)
+    - [<span id="BubbleSort">BubbleSort</span>](#bubblesort)
+    - [<span id="InsertionSort">InsertionSort</span>](#insertionsort)
+    - [<span id="SelectionSort">SelectionSort</span>](#selectionsort)
+    - [<span id="ShellSort">ShellSort</span>](#shellsort)
+    - [<span id="QuickSort">QuickSort</span>](#quicksort)
+    - [<span id="HeapSort">HeapSort</span>](#heapsort)
+    - [<span id="MergeSort">MergeSort</span>](#mergesort)
+    - [<span id="CountSort">CountSort</span>](#countsort)
+    - [<span id="BinarySearch">BinarySearch</span>](#binarysearch)
+    - [<span id="BinaryIterativeSearch">BinaryIterativeSearch</span>](#binaryiterativesearch)
+    - [<span id="LinearSearch">LinearSearch</span>](#linearsearch)
+    - [<span id="LRUCache">LRUCache</span>](#lrucache)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -46,7 +51,7 @@ import (
 <b>Signature:</b>
 
 ```go
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -76,9 +81,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.BubbleSort(intSlice, comparator)
+    algorithm.BubbleSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -91,7 +96,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -141,9 +146,9 @@ func main() {
         {Name: "e", Age: 28},
     }
     comparator := &peopleAgeComparator{}
-    sortedPeople := algorithm.InsertionSort(peoples, comparator)
+    algorithm.InsertionSort(peoples, comparator)
 
-    fmt.Println(sortedSlice) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
+    fmt.Println(peoples) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
 }
 ```
 
@@ -156,7 +161,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -186,9 +191,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.SelectionSort(intSlice, comparator)
+    algorithm.SelectionSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -201,7 +206,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -231,9 +236,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.ShellSort(intSlice, comparator)
+    algorithm.ShellSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -246,7 +251,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T
+func QuickSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -276,9 +281,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.QuickSort(intSlice, 0, len(intSlice)-1, comparator)
+    algorithm.QuickSort(intSlice, 0, len(intSlice)-1, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -291,7 +296,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -321,9 +326,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.HeapSort(intSlice, comparator)
+    algorithm.HeapSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -336,7 +341,7 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func MergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T
+func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -366,9 +371,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.MergeSort(intSlice, 0, len(intSlice)-1, comparator)
+    algorithm.MergeSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 

docs/algorithm_zh-CN.md

@@ -21,18 +21,23 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
-- [BubbleSort](#BubbleSort)
-- [CountSort](#CountSort)
-- [HeapSort](#HeapSort)
-- [InsertionSort](#InsertionSort)
-- [MergeSort](#MergeSort)
-- [QuickSort](#QuickSort)
-- [SelectionSort](#SelectionSort)
-- [ShellSort](#ShellSort)
-- [BinarySearch](#BinarySearch)
-- [BinaryIterativeSearch](#BinaryIterativeSearch)
-- [LinearSearch](#LinearSearch)
-- [LRUCache](#LRUCache)
+- [Algorithm](#algorithm)
+  - [源码](#源码)
+  - [用法](#用法)
+  - [目录](#目录)
+  - [文档](#文档)
+    - [<span id="BubbleSort">BubbleSort</span>](#bubblesort)
+    - [<span id="InsertionSort">InsertionSort</span>](#insertionsort)
+    - [<span id="SelectionSort">SelectionSort</span>](#selectionsort)
+    - [<span id="ShellSort">ShellSort</span>](#shellsort)
+    - [<span id="QuickSort">QuickSort</span>](#quicksort)
+    - [<span id="HeapSort">HeapSort</span>](#heapsort)
+    - [<span id="MergeSort">MergeSort</span>](#mergesort)
+    - [<span id="CountSort">CountSort</span>](#countsort)
+    - [<span id="BinarySearch">BinarySearch</span>](#binarysearch)
+    - [<span id="BinaryIterativeSearch">BinaryIterativeSearch</span>](#binaryiterativesearch)
+    - [<span id="LinearSearch">LinearSearch</span>](#linearsearch)
+    - [<span id="LRUCache">LRUCache</span>](#lrucache)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -46,7 +51,7 @@ import (
 <b>函数签名:</b>
 
 ```go
-func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -76,9 +81,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.BubbleSort(intSlice, comparator)
+    algorithm.BubbleSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -91,7 +96,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -141,9 +146,9 @@ func main() {
         {Name: "e", Age: 28},
     }
     comparator := &peopleAgeComparator{}
-    sortedPeople := algorithm.InsertionSort(peoples, comparator)
+    algorithm.InsertionSort(peoples, comparator)
 
-    fmt.Println(sortedSlice) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
+    fmt.Println(intSlice) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
 }
 ```
 
@@ -156,7 +161,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -186,9 +191,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.SelectionSort(intSlice, comparator)
+    algorithm.SelectionSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -201,7 +206,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
+func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -231,9 +236,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.ShellSort(intSlice, comparator)
+    algorithm.ShellSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -276,9 +281,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.QuickSort(intSlice, 0, len(intSlice)-1, comparator)
+    algorithm.QuickSort(intSlice, 0, len(intSlice)-1, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -321,9 +326,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.HeapSort(intSlice, comparator)
+    algorithm.HeapSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 
@@ -336,7 +341,7 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func MergeSort[T any](slice []T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) []T
+func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 <b>Example:</b>
 
@@ -366,9 +371,9 @@ func main() {
 
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
-    sortedSlice := algorithm.MergeSort(intSlice, 0, len(intSlice)-1, comparator)
+    algorithm.MergeSort(intSlice, comparator)
 
-    fmt.Println(sortedSlice) //[]int{1, 2, 3, 4, 5, 6}
+    fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
 ```
 

maputil/map.go

@@ -69,7 +69,7 @@ func Intersect[K comparable, V any](maps ...map[K]V) map[K]V {
 		return maps[0]
 	}
 
-	res := make(map[K]V)
+	var res map[K]V
 
 	reducer := func(m1, m2 map[K]V) map[K]V {
 		m := make(map[K]V)
@@ -93,7 +93,6 @@ func Intersect[K comparable, V any](maps ...map[K]V) map[K]V {
 	return res
 }
 
-
 // Minus creates an map of whose key in mapA but not in mapB
 func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V {
 	res := make(map[K]V)

netutil/http.go

@@ -6,7 +6,8 @@
 // HttpGet, HttpPost, HttpDelete, HttpPut, HttpPatch, function param `url` is required.
 // HttpGet, HttpPost, HttpDelete, HttpPut, HttpPatch, function param `params` is variable, the order is:
 // params[0] is header which type should be http.Header or map[string]string,
-// params[1] is query param which type should be url.Values or map[string]any,
+// params[1] is query param which type should be url.Values or map[string]any, when content-type header is
+// multipart/form-data or application/x-www-form-urlencoded, params[1] should be url.Values
 // params[2] is post body which type should be []byte.
 // params[3] is http client which type should be http.Client.
 package netutil

netutil/http_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"io/ioutil"
 	"log"
+	"net/url"
 	"testing"
 
 	"github.com/duke-git/lancet/v2/internal"
@@ -46,6 +47,29 @@ func TestHttpPost(t *testing.T) {
 	t.Log("response: ", resp.StatusCode, string(body))
 }
 
+func TestHttpPostFormData(t *testing.T) {
+	apiUrl := "https://jsonplaceholder.typicode.com/todos"
+	header := map[string]string{
+		// "Content-Type": "application/x-www-form-urlencoded",
+		"Content-Type": "multipart/form-data",
+	}
+	type Todo struct {
+		UserId int    `json:"userId"`
+		Title  string `json:"title"`
+	}
+	postData := url.Values{}
+	postData.Add("userId", "1")
+	postData.Add("title", "TestAddToDo")
+
+	resp, err := HttpPost(apiUrl, header, postData, nil)
+	if err != nil {
+		log.Fatal(err)
+		t.FailNow()
+	}
+	body, _ := ioutil.ReadAll(resp.Body)
+	t.Log("response: ", resp.StatusCode, string(body))
+}
+
 func TestHttpPut(t *testing.T) {
 	url := "https://jsonplaceholder.typicode.com/todos/1"
 	header := map[string]string{

netutil/net_internal.go

@@ -81,10 +81,16 @@ func setHeaderAndQueryAndBody(req *http.Request, reqUrl string, header, queryPar
 	if err != nil {
 		return err
 	}
-	err = setBodyByte(req, body)
+	if req.Header.Get("Content-Type") == "multipart/form-data" || req.Header.Get("Content-Type") == "application/x-www-form-urlencoded" {
+		formData := queryParam.(url.Values)
+		err = setBodyByte(req, []byte(formData.Encode()))
+	} else {
+		err = setBodyByte(req, body)
+	}
 	if err != nil {
 		return err
 	}
+
 	return nil
 }