build

docs/chapter_stack_and_queue/queue.md

@@ -684,9 +684,11 @@ comments: true
     class LinkedListQueue {
         private var front: ListNode? // 头节点
         private var rear: ListNode? // 尾节点
-        private var _size = 0
+        private var _size: Int
 
-        init() {}
+        init() {
+            _size = 0
+        }
 
         /* 获取队列的长度 */
         func size() -> Int {
@@ -1605,12 +1607,14 @@ comments: true
     /* 基于环形数组实现的队列 */
     class ArrayQueue {
         private var nums: [Int] // 用于存储队列元素的数组
-        private var front = 0 // 队首指针，指向队首元素
-        private var queSize = 0 // 队列长度
+        private var front: Int // 队首指针，指向队首元素
+        private var _size: Int // 队列长度
 
         init(capacity: Int) {
             // 初始化数组
             nums = Array(repeating: 0, count: capacity)
+            front = 0
+            _size = 0
         }
 
         /* 获取队列的容量 */
@@ -1620,12 +1624,12 @@ comments: true
 
         /* 获取队列的长度 */
         func size() -> Int {
-            queSize
+            _size
         }
 
         /* 判断队列是否为空 */
         func isEmpty() -> Bool {
-            queSize == 0
+            size() == 0
         }
 
         /* 入队 */
@@ -1636,10 +1640,10 @@ comments: true
             }
             // 计算队尾指针，指向队尾索引 + 1
             // 通过取余操作实现 rear 越过数组尾部后回到头部
-            let rear = (front + queSize) % capacity()
+            let rear = (front + size()) % capacity()
             // 将 num 添加至队尾
             nums[rear] = num
-            queSize += 1
+            _size += 1
         }
 
         /* 出队 */
@@ -1648,7 +1652,7 @@ comments: true
             let num = peek()
             // 队首指针向后移动一位，若越过尾部，则返回到数组头部
             front = (front + 1) % capacity()
-            queSize -= 1
+            _size -= 1
             return num
         }
 
@@ -1663,11 +1667,7 @@ comments: true
         /* 返回数组 */
         func toArray() -> [Int] {
             // 仅转换有效长度范围内的列表元素
-            var res = Array(repeating: 0, count: queSize)
-            for (i, j) in sequence(first: (0, front), next: { $0 < self.queSize - 1 ? ($0 + 1, $1 + 1) : nil }) {
-                res[i] = nums[j % capacity()]
-            }
-            return res
+            (front ..< front + size()).map { nums[$0 % capacity()] }
         }
     }
     ```