Add Go codes to docs, including

the chapter of stack and queue, the chapter of tree.

codes/go/chapter_stack_and_queue/array_queue.go

@@ -4,50 +4,45 @@
 
 package chapter_stack_and_queue
 
-import (
-	"fmt"
-	"strings"
-)
-
-// ArrayQueue 基于环形数组实现的队列, 不支持扩容
+/* 基于环形数组实现的队列 */
 type ArrayQueue struct {
-	data     []any // 用于存储队列元素的数组
+	data     []int // 用于存储队列元素的数组
 	capacity int   // 队列容量（即最多容量的元素个数）
-	head     int   // 头指针，指向队首
-	tail     int   // 尾指针，指向队尾 + 1
+	front    int   // 头指针，指向队首
+	rear     int   // 尾指针，指向队尾 + 1
 }
 
 // NewArrayQueue 基于环形数组实现的队列
 func NewArrayQueue(capacity int) *ArrayQueue {
 	return &ArrayQueue{
-		data:     make([]any, capacity),
+		data:     make([]int, capacity),
 		capacity: capacity,
-		head:     0,
-		tail:     0,
+		front:    0,
+		rear:     0,
 	}
 }
 
 // Size 获取队列的长度
 func (q *ArrayQueue) Size() int {
-	size := (q.capacity + q.tail - q.head) % q.capacity
+	size := (q.capacity + q.rear - q.front) % q.capacity
 	return size
 }
 
 // IsEmpty 判断队列是否为空
 func (q *ArrayQueue) IsEmpty() bool {
-	return q.tail-q.head == 0
+	return q.rear-q.front == 0
 }
 
 // Offer 入队
-func (q *ArrayQueue) Offer(v any) {
-	// 当 tail == capacity 表示队列已满
+func (q *ArrayQueue) Offer(v int) {
+	// 当 rear == capacity 表示队列已满
 	if q.Size() == q.capacity {
 		return
 	}
 	// 尾结点后添加
-	q.data[q.tail] = v
+	q.data[q.rear] = v
 	// 尾指针向后移动一位，越过尾部后返回到数组头部
-	q.tail = (q.tail + 1) % q.capacity
+	q.rear = (q.rear + 1) % q.capacity
 }
 
 // Poll 出队
@@ -55,9 +50,9 @@ func (q *ArrayQueue) Poll() any {
 	if q.IsEmpty() {
 		return nil
 	}
-	v := q.data[q.head]
+	v := q.data[q.front]
 	// 队头指针向后移动一位，若越过尾部则返回到数组头部
-	q.head = (q.head + 1) % q.capacity
+	q.front = (q.front + 1) % q.capacity
 	return v
 }
 
@@ -66,27 +61,11 @@ func (q *ArrayQueue) Peek() any {
 	if q.IsEmpty() {
 		return nil
 	}
-	v := q.data[q.head]
+	v := q.data[q.front]
 	return v
 }
 
-func (q *ArrayQueue) Print() {
-	fmt.Println(q.toString())
-}
-
-// toString 通过字符串的方式输出
-func (q *ArrayQueue) toString() string {
-	// 为空时
-	if q.IsEmpty() {
-		return "empty items"
-	}
-	var builder strings.Builder
-	size := q.Size()
-	str := fmt.Sprintf("%+v", q.data[q.head])
-	for i := 1; i < size; i++ {
-		builder.WriteString(str + " -> ")
-		str = fmt.Sprintf("%+v", q.data[(i+q.head)%q.capacity])
-	}
-	builder.WriteString(str)
-	return builder.String()
+// 获取 Slice 用于打印
+func (s *ArrayQueue) toSlice() []int {
+	return s.data[s.front:s.rear]
 }

codes/go/chapter_stack_and_queue/array_stack.go

@@ -4,13 +4,7 @@
 
 package chapter_stack_and_queue
 
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-// ArrayStack 基于数组实现的栈
+/* 基于数组实现的栈 */
 type ArrayStack struct {
 	data []int // 数据
 }
@@ -38,6 +32,7 @@ func (s *ArrayStack) Push(v int) {
 	s.data = append(s.data, v)
 }
 
+// Pop 出栈
 func (s *ArrayStack) Pop() any {
 	// 弹出栈前，先判断是否为空
 	if s.IsEmpty() {
@@ -48,6 +43,7 @@ func (s *ArrayStack) Pop() any {
 	return val
 }
 
+// Peek 获取栈顶元素
 func (s *ArrayStack) Peek() any {
 	if s.IsEmpty() {
 		return nil
@@ -56,18 +52,7 @@ func (s *ArrayStack) Peek() any {
 	return val
 }
 
-func (s *ArrayStack) Print() {
-	fmt.Println(s.toString())
-}
-
-func (s *ArrayStack) toString() string {
-	var builder strings.Builder
-	if s.IsEmpty() {
-		return "empty stack"
-	}
-	for i := len(s.data) - 1; i > 0; i-- {
-		builder.WriteString(strconv.Itoa(s.data[i]) + " -> ")
-	}
-	builder.WriteString(strconv.Itoa(s.data[0]))
-	return builder.String()
+// 获取 Slice 用于打印
+func (s *ArrayStack) toSlice() []int {
+	return s.data
 }

codes/go/chapter_stack_and_queue/deque.go

@@ -1,26 +0,0 @@
-// File: deque.go
-// Created Time: 2022-11-29
-// Author: Reanon (793584285@qq.com)
-
-package chapter_stack_and_queue
-
-type Deque interface {
-	// OfferFirst 元素入队
-	OfferFirst(num any)
-	// OfferLast 元素入队
-	OfferLast(num any)
-	// PeekFirst 访问首元素
-	PeekFirst() any
-	// PeekLast 访问尾元素
-	PeekLast() any
-	// PollFirst 元素出队
-	PollFirst() any
-	// PollLast 元素出队
-	PollLast() any
-	// Size 获取队列长度
-	Size() int
-	// IsEmpty 队列是否为空
-	IsEmpty() bool
-	// toString 队列输出为字符串
-	toString() string
-}

codes/go/chapter_stack_and_queue/deque_test.go

@@ -4,12 +4,54 @@
 
 package chapter_stack_and_queue
 
-import "testing"
+import (
+	"container/list"
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestDeque(t *testing.T) {
+	/* 初始化双向队列 */
+	// 在 Go 中，将 list 作为双向队列使用
+	deque := list.New()
+
+	/* 元素入队 */
+	deque.PushBack(2)
+	deque.PushBack(5)
+	deque.PushBack(4)
+	deque.PushFront(3)
+	deque.PushFront(1)
+	fmt.Print("双向队列 deque = ")
+	PrintList(deque)
+
+	/* 访问元素 */
+	front := deque.Front()
+	fmt.Println("队首元素 front =", front.Value)
+	rear := deque.Back()
+	fmt.Println("队尾元素 rear =", rear.Value)
+
+	/* 元素出队 */
+	deque.Remove(front)
+	fmt.Print("队首出队元素 front = ", front.Value, "，队首出队后 deque = ")
+	PrintList(deque)
+	deque.Remove(rear)
+	fmt.Print("队尾出队元素 rear = ", rear.Value, "，队尾出队后 deque = ")
+	PrintList(deque)
+
+	/* 获取双向队列的长度 */
+	size := deque.Len()
+	fmt.Println("双向队列长度 size =", size)
+
+	/* 判断双向队列是否为空 */
+	isEmpty := deque.Len() == 0
+	fmt.Println("双向队列是否为空 =", isEmpty)
+}
 
 func TestLinkedListDeque(t *testing.T) {
 	// 初始化队列
-	var deque Deque
-	deque = NewLinkedListDeque()
+	deque := NewLinkedListDeque()
 
 	// 元素入队
 	deque.OfferLast(2)
@@ -17,27 +59,30 @@ func TestLinkedListDeque(t *testing.T) {
 	deque.OfferLast(4)
 	deque.OfferFirst(3)
 	deque.OfferFirst(1)
-	t.Log("队列 deque = ", deque.toString())
+	fmt.Print("队列 deque = ")
+	PrintList(deque.toList())
 
 	// 访问队首元素
-	peekFirst := deque.PeekFirst()
-	t.Log("队首元素 peek = ", peekFirst)
-	peekLast := deque.PeekLast()
-	t.Log("队尾元素 peek = ", peekLast)
+	front := deque.PeekFirst()
+	fmt.Println("队首元素 front =", front)
+	rear := deque.PeekLast()
+	fmt.Println("队尾元素 rear =", rear)
 
 	// 元素出队
 	pollFirst := deque.PollFirst()
-	t.Log("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ", deque.toString())
+	fmt.Print("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ")
+	PrintList(deque.toList())
 	pollLast := deque.PollLast()
-	t.Log("队尾出队元素 pollLast  = ", pollLast, "，队尾出队后 deque = ", deque.toString())
+	fmt.Print("队尾出队元素 pollLast = ", pollLast, "，队尾出队后 deque = ")
+	PrintList(deque.toList())
 
 	// 获取队的长度
 	size := deque.Size()
-	t.Log("队的长度 size = ", size)
+	fmt.Println("队的长度 size =", size)
 
 	// 判断是否为空
 	isEmpty := deque.IsEmpty()
-	t.Log("队是否为空 = ", isEmpty)
+	fmt.Println("队是否为空 =", isEmpty)
 }
 
 // BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro

codes/go/chapter_stack_and_queue/linkedlist_deque.go

@@ -6,97 +6,79 @@ package chapter_stack_and_queue
 
 import (
 	"container/list"
-	"fmt"
-	"strings"
 )
 
 // LinkedListDeque 基于链表实现的双端队列, 使用内置包 list 来实现栈
 type LinkedListDeque struct {
-	list *list.List
+	data *list.List
 }
 
 // NewLinkedListDeque 初始化双端队列
 func NewLinkedListDeque() *LinkedListDeque {
 	return &LinkedListDeque{
-		list: list.New(),
+		data: list.New(),
 	}
 }
 
-// OfferFirst 元素入队
+// OfferFirst 队首元素入队
 func (s *LinkedListDeque) OfferFirst(value any) {
-	s.list.PushFront(value)
+	s.data.PushFront(value)
 }
 
-// OfferLast 元素入队
+// OfferLast 队尾元素入队
 func (s *LinkedListDeque) OfferLast(value any) {
-	s.list.PushBack(value)
+	s.data.PushBack(value)
 }
 
-// PollFirst 元素出队
+// PollFirst 队首元素出队
 func (s *LinkedListDeque) PollFirst() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Front()
-	s.list.Remove(e)
+	e := s.data.Front()
+	s.data.Remove(e)
 	return e.Value
 }
 
-// PollLast 元素出队
+// PollLast 队尾元素出队
 func (s *LinkedListDeque) PollLast() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Back()
-	s.list.Remove(e)
+	e := s.data.Back()
+	s.data.Remove(e)
 	return e.Value
 }
 
-// PeekFirst 访问首元素
+// PeekFirst 访问队首元素
 func (s *LinkedListDeque) PeekFirst() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Front()
+	e := s.data.Front()
 	return e.Value
 }
 
-// PeekLast 访问尾元素
+// PeekLast 访问队尾元素
 func (s *LinkedListDeque) PeekLast() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Back()
+	e := s.data.Back()
 	return e.Value
 }
 
 // Size 获取队列的长度
 func (s *LinkedListDeque) Size() int {
-	return s.list.Len()
+	return s.data.Len()
 }
 
 // IsEmpty 判断队列是否为空
 func (s *LinkedListDeque) IsEmpty() bool {
-	return s.list.Len() == 0
+	return s.data.Len() == 0
 }
 
-func (s *LinkedListDeque) Print() {
-	fmt.Println(s.toString())
-}
-
-func (s *LinkedListDeque) toString() string {
-	var builder strings.Builder
-	if s.IsEmpty() {
-		fmt.Println("empty stack")
-	}
-	e := s.list.Front()
-	// 强转为 string, 会影响效率
-	str := fmt.Sprintf("%v", e.Value)
-	for e.Next() != nil {
-		builder.WriteString(str + " -> ")
-		e = e.Next()
-		str = fmt.Sprintf("%v", e.Value)
-	}
-	builder.WriteString(str)
-	return builder.String()
+// 获取 List 用于打印
+func (s *LinkedListDeque) toList() *list.List {
+	return s.data
 }

codes/go/chapter_stack_and_queue/linkedlist_queue.go

@@ -6,25 +6,24 @@ package chapter_stack_and_queue
 
 import (
 	"container/list"
-	"fmt"
-	"strings"
 )
 
-// LinkedListQueue 基于链表实现的队列, 使用内置包 list 来实现栈
+/* 基于链表实现的队列 */
 type LinkedListQueue struct {
-	list *list.List
+	// 使用内置包 list 来实现队列
+	data *list.List
 }
 
 // NewLinkedListQueue 初始化链表
 func NewLinkedListQueue() *LinkedListQueue {
 	return &LinkedListQueue{
-		list: list.New(),
+		data: list.New(),
 	}
 }
 
 // Offer 入队
 func (s *LinkedListQueue) Offer(value any) {
-	s.list.PushBack(value)
+	s.data.PushBack(value)
 }
 
 // Poll 出队
@@ -32,8 +31,8 @@ func (s *LinkedListQueue) Poll() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Front()
-	s.list.Remove(e)
+	e := s.data.Front()
+	s.data.Remove(e)
 	return e.Value
 }
 
@@ -42,37 +41,21 @@ func (s *LinkedListQueue) Peek() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Front()
+	e := s.data.Front()
 	return e.Value
 }
 
 // Size 获取队列的长度
 func (s *LinkedListQueue) Size() int {
-	return s.list.Len()
+	return s.data.Len()
 }
 
 // IsEmpty 判断队列是否为空
 func (s *LinkedListQueue) IsEmpty() bool {
-	return s.list.Len() == 0
+	return s.data.Len() == 0
 }
 
-func (s *LinkedListQueue) Print() {
-	fmt.Println(s.toString())
-}
-
-func (s *LinkedListQueue) toString() string {
-	var builder strings.Builder
-	if s.IsEmpty() {
-		fmt.Println("empty stack")
-	}
-	e := s.list.Front()
-	// 强转为 string, 会影响效率
-	str := fmt.Sprintf("%v", e.Value)
-	for e.Next() != nil {
-		builder.WriteString(str + " -> ")
-		e = e.Next()
-		str = fmt.Sprintf("%v", e.Value)
-	}
-	builder.WriteString(str)
-	return builder.String()
+// 获取 List 用于打印
+func (s *LinkedListQueue) toList() *list.List {
+	return s.data
 }

codes/go/chapter_stack_and_queue/linkedlist_stack.go

@@ -6,25 +6,24 @@ package chapter_stack_and_queue
 
 import (
 	"container/list"
-	"fmt"
-	"strings"
 )
 
-// LinkedListStack 基于链表实现的栈, 使用内置包 list 来实现栈
+/* 基于链表实现的栈 */
 type LinkedListStack struct {
-	list *list.List
+	// 使用内置包 list 来实现栈
+	data *list.List
 }
 
 // NewLinkedListStack 初始化链表
 func NewLinkedListStack() *LinkedListStack {
 	return &LinkedListStack{
-		list: list.New(),
+		data: list.New(),
 	}
 }
 
 // Push 入栈
 func (s *LinkedListStack) Push(value int) {
-	s.list.PushBack(value)
+	s.data.PushBack(value)
 }
 
 // Pop 出栈
@@ -32,8 +31,8 @@ func (s *LinkedListStack) Pop() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Back()
-	s.list.Remove(e)
+	e := s.data.Back()
+	s.data.Remove(e)
 	return e.Value
 }
 
@@ -42,37 +41,21 @@ func (s *LinkedListStack) Peek() any {
 	if s.IsEmpty() {
 		return nil
 	}
-	e := s.list.Back()
+	e := s.data.Back()
 	return e.Value
 }
 
 // Size 获取栈的长度
 func (s *LinkedListStack) Size() int {
-	return s.list.Len()
+	return s.data.Len()
 }
 
 // IsEmpty 判断栈是否为空
 func (s *LinkedListStack) IsEmpty() bool {
-	return s.list.Len() == 0
+	return s.data.Len() == 0
 }
 
-func (s *LinkedListStack) Print() {
-	fmt.Println(s.toString())
-}
-
-func (s *LinkedListStack) toString() string {
-	var builder strings.Builder
-	if s.IsEmpty() {
-		fmt.Println("empty stack")
-	}
-	e := s.list.Back()
-	// 强转为 string, 会影响效率
-	str := fmt.Sprintf("%v", e.Value)
-	for e.Prev() != nil {
-		builder.WriteString(str + " -> ")
-		e = e.Prev()
-		str = fmt.Sprintf("%v", e.Value)
-	}
-	builder.WriteString(str)
-	return builder.String()
+// 获取 List 用于打印
+func (s *LinkedListStack) toList() *list.List {
+	return s.data
 }

codes/go/chapter_stack_and_queue/queue.go

@@ -1,20 +0,0 @@
-// File: queue.go
-// Created Time: 2022-11-29
-// Author: Reanon (793584285@qq.com)
-
-package chapter_stack_and_queue
-
-type Queue interface {
-	// Offer 元素入队
-	Offer(num any)
-	// Peek 访问首元素
-	Peek() any
-	// Poll 元素出队
-	Poll() any
-	// Size 获取队列长度
-	Size() int
-	// IsEmpty 队列是否为空
-	IsEmpty() bool
-	// toString 队列输出为字符串
-	toString() string
-}

codes/go/chapter_stack_and_queue/queue_test.go

@@ -4,67 +4,108 @@
 
 package chapter_stack_and_queue
 
-import "testing"
+import (
+	"container/list"
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestQueue(t *testing.T) {
+	/* 初始化队列 */
+	// 在 Go 中，将 list 作为队列来使用
+	queue := list.New()
+
+	/* 元素入队 */
+	queue.PushBack(1)
+	queue.PushBack(3)
+	queue.PushBack(2)
+	queue.PushBack(5)
+	queue.PushBack(4)
+	fmt.Print("队列 queue = ")
+	PrintList(queue)
+
+	/* 访问队首元素 */
+	peek := queue.Front()
+	fmt.Println("队首元素 peek =", peek.Value)
+
+	/* 元素出队 */
+	poll := queue.Front()
+	queue.Remove(poll)
+	fmt.Print("出队元素 poll = ", poll.Value, "，出队后 queue = ")
+	PrintList(queue)
+
+	/* 获取队列的长度 */
+	size := queue.Len()
+	fmt.Println("队列长度 size =", size)
+
+	/* 判断队列是否为空 */
+	isEmpty := queue.Len() == 0
+	fmt.Println("队列是否为空 =", isEmpty)
+}
 
 func TestArrayQueue(t *testing.T) {
 	// 初始化队列，使用队列的通用接口
-	var queue Queue
 	capacity := 10
-	queue = NewArrayQueue(capacity)
+	queue := NewArrayQueue(capacity)
 
 	// 元素入队
 	queue.Offer(1)
-	queue.Offer(2)
 	queue.Offer(3)
-	queue.Offer(4)
+	queue.Offer(2)
 	queue.Offer(5)
-	t.Log("队列 queue = ", queue.toString())
+	queue.Offer(4)
+	fmt.Print("队列 queue = ")
+	PrintSlice(queue.toSlice())
 
 	// 访问队首元素
 	peek := queue.Peek()
-	t.Log("队首元素 peek = ", peek)
+	fmt.Println("队首元素 peek =", peek)
 
 	// 元素出队
-	pop := queue.Poll()
-	t.Log("出队元素 pop  = ", pop, ", 出队后 queue =", queue.toString())
+	poll := queue.Poll()
+	fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ")
+	PrintSlice(queue.toSlice())
 
 	// 获取队的长度
 	size := queue.Size()
-	t.Log("队的长度 size = ", size)
+	fmt.Println("队的长度 size =", size)
 
 	// 判断是否为空
 	isEmpty := queue.IsEmpty()
-	t.Log("队是否为空 = ", isEmpty)
+	fmt.Println("队是否为空 =", isEmpty)
 }
 
 func TestLinkedListQueue(t *testing.T) {
 	// 初始化队
-	var queue Queue
-	queue = NewLinkedListQueue()
+	queue := NewLinkedListQueue()
 
 	// 元素入队
 	queue.Offer(1)
-	queue.Offer(2)
 	queue.Offer(3)
-	queue.Offer(4)
+	queue.Offer(2)
 	queue.Offer(5)
-	t.Log("队列 queue = ", queue.toString())
+	queue.Offer(4)
+	fmt.Print("队列 queue = ")
+	PrintList(queue.toList())
 
 	// 访问队首元素
 	peek := queue.Peek()
-	t.Log("队首元素 peek = ", peek)
+	fmt.Println("队首元素 peek =", peek)
 
 	// 元素出队
-	pop := queue.Poll()
-	t.Log("出队元素 pop  = ", pop, ", 出队后 queue =", queue.toString())
+	poll := queue.Poll()
+	fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ")
+	PrintList(queue.toList())
 
 	// 获取队的长度
 	size := queue.Size()
-	t.Log("队的长度 size = ", size)
+	fmt.Println("队的长度 size =", size)
 
 	// 判断是否为空
 	isEmpty := queue.IsEmpty()
-	t.Log("队是否为空 = ", isEmpty)
+	fmt.Println("队是否为空 =", isEmpty)
 }
 
 // BenchmarkArrayQueue 8 ns/op in Mac M1 Pro

codes/go/chapter_stack_and_queue/stack.go

@@ -1,20 +0,0 @@
-// File: stack.go
-// Created Time: 2022-11-26
-// Author: Reanon (793584285@qq.com)
-
-package chapter_stack_and_queue
-
-type Stack interface {
-	// Push 元素入栈
-	Push(num int)
-	// Peek 访问栈顶元素
-	Peek() any
-	// Pop 元素出栈
-	Pop() any
-	// Size 栈的长度
-	Size() int
-	// IsEmpty 栈是否为空
-	IsEmpty() bool
-	// toString 栈输出为字符串
-	toString() string
-}

codes/go/chapter_stack_and_queue/stack_test.go

@@ -4,65 +4,105 @@
 
 package chapter_stack_and_queue
 
-import "testing"
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestStack(t *testing.T) {
+	/* 初始化栈 */
+	// 在 Go 中，推荐将 Slice 当作栈来使用
+	var stack []int
+
+	/* 元素入栈 */
+	stack = append(stack, 1)
+	stack = append(stack, 3)
+	stack = append(stack, 2)
+	stack = append(stack, 5)
+	stack = append(stack, 4)
+	fmt.Print("栈 = ")
+	PrintSlice(stack)
+
+	/* 访问栈顶元素 */
+	peek := stack[len(stack)-1]
+	fmt.Println("栈顶元素 peek =", peek)
+
+	/* 元素出栈 */
+	pop := stack[len(stack)-1]
+	stack = stack[:len(stack)-1]
+	fmt.Print("出栈元素 pop = ", pop, "，出栈后 stack = ")
+	PrintSlice(stack)
+
+	/* 获取栈的长度 */
+	size := len(stack)
+	fmt.Println("栈的长度 size =", size)
+
+	/* 判断是否为空 */
+	isEmpty := len(stack) == 0
+	fmt.Println("栈是否为空 =", isEmpty)
+}
 
 func TestArrayStack(t *testing.T) {
 	// 初始化栈, 使用接口承接
-	var stack Stack
-	stack = NewArrayStack()
+	stack := NewArrayStack()
 
 	// 元素入栈
 	stack.Push(1)
-	stack.Push(2)
 	stack.Push(3)
-	stack.Push(4)
+	stack.Push(2)
 	stack.Push(5)
-	t.Log("栈 stack = ", stack.toString())
+	stack.Push(4)
+	fmt.Print("栈 stack = ")
+	PrintSlice(stack.toSlice())
 
 	// 访问栈顶元素
 	peek := stack.Peek()
-	t.Log("栈顶元素 peek = ", peek)
+	fmt.Println("栈顶元素 peek =", peek)
 
 	// 元素出栈
 	pop := stack.Pop()
-	t.Log("出栈元素 pop  = ", pop, ", 出栈后 stack =", stack.toString())
+	fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ")
+	PrintSlice(stack.toSlice())
 
 	// 获取栈的长度
 	size := stack.Size()
-	t.Log("栈的长度 size = ", size)
+	fmt.Println("栈的长度 size =", size)
 
 	// 判断是否为空
 	isEmpty := stack.IsEmpty()
-	t.Log("栈是否为空 = ", isEmpty)
+	fmt.Println("栈是否为空 =", isEmpty)
 }
 
 func TestLinkedListStack(t *testing.T) {
 	// 初始化栈
-	var stack Stack
-	stack = NewLinkedListStack()
+	stack := NewLinkedListStack()
 	// 元素入栈
 	stack.Push(1)
-	stack.Push(2)
 	stack.Push(3)
-	stack.Push(4)
+	stack.Push(2)
 	stack.Push(5)
-	t.Log("栈 stack = ", stack.toString())
+	stack.Push(4)
+	fmt.Print("栈 stack = ")
+	PrintList(stack.toList())
 
 	// 访问栈顶元素
 	peek := stack.Peek()
-	t.Log("栈顶元素 peek = ", peek)
+	fmt.Println("栈顶元素 peek =", peek)
 
 	// 元素出栈
 	pop := stack.Pop()
-	t.Log("出栈元素 pop  = ", pop, ", 出栈后 stack =", stack.toString())
+	fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ")
+	PrintList(stack.toList())
 
 	// 获取栈的长度
 	size := stack.Size()
-	t.Log("栈的长度 size = ", size)
+	fmt.Println("栈的长度 size =", size)
 
 	// 判断是否为空
 	isEmpty := stack.IsEmpty()
-	t.Log("栈是否为空 = ", isEmpty)
+	fmt.Println("栈是否为空 =", isEmpty)
 }
 
 // BenchmarkArrayStack 8 ns/op in Mac M1 Pro