refactor: rename function 'EnQueue' -> 'Enqueue', 'DeQueue' -> 'Dequeue'

datastructure/queue/circularqueue.go

@@ -68,8 +68,8 @@ func (q *CircularQueue[T]) Back() T {
 	return q.data[q.size-1]
 }
 
-// EnQueue put element into queue
-func (q *CircularQueue[T]) EnQueue(value T) error {
+// Enqueue put element into queue
+func (q *CircularQueue[T]) Enqueue(value T) error {
 	if q.IsFull() {
 		return errors.New("queue is full!")
 	}
@@ -80,8 +80,8 @@ func (q *CircularQueue[T]) EnQueue(value T) error {
 	return nil
 }
 
-// DeQueue remove head element of queue and return it, if queue is empty, return nil and error
-func (q *CircularQueue[T]) DeQueue() (*T, error) {
+// Dequeue remove head element of queue and return it, if queue is empty, return nil and error
+func (q *CircularQueue[T]) Dequeue() (*T, error) {
 	if q.IsEmpty() {
 		return nil, errors.New("queue is empty")
 	}

datastructure/queue/circularqueue_test.go

@@ -6,47 +6,47 @@ import (
 	"github.com/duke-git/lancet/v2/internal"
 )
 
-func TestCircularQueue_EnQueue(t *testing.T) {
-	assert := internal.NewAssert(t, "TestCircularQueue_EnQueue")
+func TestCircularQueue_Enqueue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestCircularQueue_Enqueue")
 
 	queue := NewCircularQueue[int](6)
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
-	queue.EnQueue(4)
-	queue.EnQueue(5)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
 
 	queue.Print()
 	// assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
 	assert.Equal(5, queue.Length())
 
-	err := queue.EnQueue(6)
+	err := queue.Enqueue(6)
 	assert.IsNotNil(err)
 }
 
-func TestCircularQueue_DeQueue(t *testing.T) {
+func TestCircularQueue_Dequeue(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_DeQueue")
 
 	queue := NewCircularQueue[int](6)
 	assert.Equal(true, queue.IsEmpty())
 
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
-	queue.EnQueue(4)
-	queue.EnQueue(5)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
 
-	val, err := queue.DeQueue()
+	val, err := queue.Dequeue()
 	assert.IsNil(err)
 
 	assert.Equal(1, *val)
 	assert.Equal(false, queue.IsFull())
 
-	val, _ = queue.DeQueue()
+	val, _ = queue.Dequeue()
 	queue.Print()
 	assert.Equal(2, *val)
 
-	queue.EnQueue(6)
+	queue.Enqueue(6)
 	queue.Print()
 	assert.Equal(false, queue.IsFull())
 }
@@ -55,18 +55,18 @@ func TestCircularQueue_Front(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Front")
 
 	queue := NewCircularQueue[int](6)
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
-	queue.EnQueue(4)
-	queue.EnQueue(5)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
 
 	queue.Print()
 
-	queue.DeQueue()
-	queue.DeQueue()
-	queue.EnQueue(6)
-	queue.EnQueue(7)
+	queue.Dequeue()
+	queue.Dequeue()
+	queue.Enqueue(6)
+	queue.Enqueue(7)
 
 	queue.Print()
 
@@ -81,19 +81,19 @@ func TestCircularQueue_Back(t *testing.T) {
 	queue := NewCircularQueue[int](6)
 	assert.Equal(true, queue.IsEmpty())
 
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
-	queue.EnQueue(4)
-	queue.EnQueue(5)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
 
 	queue.Print()
 	assert.Equal(5, queue.Back())
 
-	queue.DeQueue()
-	queue.DeQueue()
-	queue.EnQueue(6)
-	queue.EnQueue(7)
+	queue.Dequeue()
+	queue.Dequeue()
+	queue.Enqueue(6)
+	queue.Enqueue(7)
 
 	queue.Print()
 	assert.Equal(7, queue.Back())
@@ -103,7 +103,7 @@ func TestCircularQueue_Contain(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Contain")
 
 	queue := NewCircularQueue[int](2)
-	queue.EnQueue(1)
+	queue.Enqueue(1)
 	assert.Equal(true, queue.Contain(1))
 	assert.Equal(false, queue.Contain(2))
 }
@@ -115,7 +115,7 @@ func TestCircularQueue_Clear(t *testing.T) {
 	assert.Equal(true, queue.IsEmpty())
 	assert.Equal(0, queue.Length())
 
-	queue.EnQueue(1)
+	queue.Enqueue(1)
 	assert.Equal(false, queue.IsEmpty())
 	assert.Equal(1, queue.Length())
 
@@ -128,19 +128,19 @@ func TestCircularQueue_Data(t *testing.T) {
 	assert := internal.NewAssert(t, "TestCircularQueue_Data")
 
 	queue := NewCircularQueue[int](6)
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
-	queue.EnQueue(4)
-	queue.EnQueue(5)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
+	queue.Enqueue(4)
+	queue.Enqueue(5)
 
 	queue.Print()
 	assert.Equal([]int{1, 2, 3, 4, 5}, queue.Data())
 
-	queue.DeQueue()
-	queue.DeQueue()
-	queue.EnQueue(6)
-	queue.EnQueue(7)
+	queue.Dequeue()
+	queue.Dequeue()
+	queue.Enqueue(6)
+	queue.Enqueue(7)
 
 	queue.Print()
 	assert.Equal([]int{3, 4, 5, 6, 7}, queue.Data())

datastructure/queue/linkedqueue.go

@@ -41,8 +41,8 @@ func (q *LinkedQueue[T]) IsEmpty() bool {
 	return q.length == 0
 }
 
-// EnQueue add element into queue
-func (q *LinkedQueue[T]) EnQueue(value T) {
+// Enqueue put element into queue
+func (q *LinkedQueue[T]) Enqueue(value T) {
 	newNode := datastructure.NewQueueNode(value)
 
 	if q.IsEmpty() {
@@ -55,8 +55,8 @@ func (q *LinkedQueue[T]) EnQueue(value T) {
 	q.length++
 }
 
-// DeQueue delete head element of queue then return it, if queue is empty, return nil and error
-func (q *LinkedQueue[T]) DeQueue() (*T, error) {
+// Dequeue delete head element of queue then return it, if queue is empty, return nil and error
+func (q *LinkedQueue[T]) Dequeue() (*T, error) {
 	if q.IsEmpty() {
 		return nil, errors.New("queue is empty")
 	}

datastructure/queue/linkedqueue_test.go

@@ -6,13 +6,13 @@ import (
 	"github.com/duke-git/lancet/v2/internal"
 )
 
-func TestLinkedQueue_EnQueue(t *testing.T) {
-	assert := internal.NewAssert(t, "TestLinkedQueue_EnQueue")
+func TestLinkedQueue_Enqueue(t *testing.T) {
+	assert := internal.NewAssert(t, "TestLinkedQueue_Enqueue")
 
 	queue := NewLinkedQueue[int]()
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 
 	queue.Print()
 
@@ -20,15 +20,15 @@ func TestLinkedQueue_EnQueue(t *testing.T) {
 	assert.Equal(3, queue.Size())
 }
 
-func TestLinkedQueue_DeQueue(t *testing.T) {
+func TestLinkedQueue_Dequeue(t *testing.T) {
 	assert := internal.NewAssert(t, "TestLinkedQueue_DeQueue")
 
 	queue := NewLinkedQueue[int]()
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 
-	val, _ := queue.DeQueue()
+	val, _ := queue.Dequeue()
 
 	queue.Print()
 
@@ -43,9 +43,9 @@ func TestLinkedQueue_Front(t *testing.T) {
 	_, err := queue.Front()
 	assert.IsNotNil(err)
 
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 
 	val, err := queue.Front()
 	assert.Equal(1, *val)
@@ -59,9 +59,9 @@ func TestLinkedQueue_Back(t *testing.T) {
 	_, err := queue.Back()
 	assert.IsNotNil(err)
 
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 
 	val, err := queue.Back()
 	assert.Equal(3, *val)
@@ -74,9 +74,9 @@ func TestLinkedQueue_Clear(t *testing.T) {
 	queue := NewLinkedQueue[int]()
 	assert.Equal(true, queue.IsEmpty())
 
-	queue.EnQueue(1)
-	queue.EnQueue(2)
-	queue.EnQueue(3)
+	queue.Enqueue(1)
+	queue.Enqueue(2)
+	queue.Enqueue(3)
 	assert.Equal(false, queue.IsEmpty())
 
 	queue.Clear()