Fix array queue.

codes/go/chapter_stack_and_queue/array_queue.go

@@ -6,54 +6,53 @@ package chapter_stack_and_queue
 
 /* 基于环形数组实现的队列 */
 type arrayQueue struct {
-	data     []int // 用于存储队列元素的数组
-	capacity int   // 队列容量（即最多容量的元素个数）
-	front    int   // 头指针，指向队首
-	rear     int   // 尾指针，指向队尾 + 1
+	nums        []int // 用于存储队列元素的数组
+	front       int   // 队首指针，指向队首元素
+	queSize     int   // 队列长度
+	queCapacity int   // 队列容量（即最大容纳元素数量）
 }
 
 // newArrayQueue 基于环形数组实现的队列
-func newArrayQueue(capacity int) *arrayQueue {
+func newArrayQueue(queCapacity int) *arrayQueue {
 	return &arrayQueue{
-		data:     make([]int, capacity),
-		capacity: capacity,
-		front:    0,
-		rear:     0,
+		nums:        make([]int, queCapacity),
+		queCapacity: queCapacity,
+		front:       0,
+		queSize:     0,
 	}
 }
 
 // size 获取队列的长度
 func (q *arrayQueue) size() int {
-	size := (q.capacity + q.rear - q.front) % q.capacity
-	return size
+	return q.queSize
 }
 
 // isEmpty 判断队列是否为空
 func (q *arrayQueue) isEmpty() bool {
-	return q.rear-q.front == 0
+	return q.queSize == 0
 }
 
 // offer 入队
-func (q *arrayQueue) offer(v int) {
-	// 当 rear == capacity 表示队列已满
-	if q.size() == q.capacity {
+func (q *arrayQueue) offer(num int) {
+	// 当 rear == queCapacity 表示队列已满
+	if q.queSize == q.queCapacity {
 		return
 	}
-	// 尾结点后添加
-	q.data[q.rear] = v
-	// 尾指针向后移动一位，越过尾部后返回到数组头部
-	q.rear = (q.rear + 1) % q.capacity
+	// 计算尾指针，指向队尾索引 + 1
+	// 通过取余操作，实现 rear 越过数组尾部后回到头部
+	rear := (q.front + q.queSize) % q.queCapacity
+	// 尾结点后添加 num
+	q.nums[rear] = num
+	q.queSize++
 }
 
 // poll 出队
 func (q *arrayQueue) poll() any {
-	if q.isEmpty() {
-		return nil
-	}
-	v := q.data[q.front]
-	// 队头指针向后移动一位，若越过尾部则返回到数组头部
-	q.front = (q.front + 1) % q.capacity
-	return v
+	num := q.peek()
+	// 队首指针向后移动一位，若越过尾部则返回到数组头部
+	q.front = (q.front + 1) % q.queCapacity
+	q.queSize--
+	return num
 }
 
 // peek 访问队首元素
@@ -61,11 +60,15 @@ func (q *arrayQueue) peek() any {
 	if q.isEmpty() {
 		return nil
 	}
-	v := q.data[q.front]
-	return v
+	return q.nums[q.front]
 }
 
 // 获取 Slice 用于打印
 func (q *arrayQueue) toSlice() []int {
-	return q.data[q.front:q.rear]
+	rear := (q.front + q.queSize)
+	if rear >= q.queCapacity {
+		rear %= q.queCapacity
+		return append(q.nums[q.front:], q.nums[:rear]...)
+	}
+	return q.nums[q.front:rear]
 }

codes/go/chapter_stack_and_queue/queue_test.go

@@ -75,6 +75,14 @@ func TestArrayQueue(t *testing.T) {
 	// 判断是否为空
 	isEmpty := queue.isEmpty()
 	fmt.Println("队是否为空 =", isEmpty)
+
+	/* 测试环形数组 */
+	for i := 0; i < 10; i++ {
+		queue.offer(i)
+		queue.poll()
+		fmt.Print("第", i, "轮入队 + 出队后 queue =")
+		PrintSlice(queue.toSlice())
+	}
 }
 
 func TestLinkedListQueue(t *testing.T) {