Fomrat the JS and TS codes with prettier.

codes/javascript/chapter_stack_and_queue/array_deque.js

@@ -6,9 +6,9 @@
 
 /* 基于环形数组实现的双向队列 */
 class ArrayDeque {
-    #nums;       // 用于存储双向队列元素的数组
-    #front;      // 队首指针，指向队首元素
-    #queSize;    // 双向队列长度
+    #nums; // 用于存储双向队列元素的数组
+    #front; // 队首指针，指向队首元素
+    #queSize; // 双向队列长度
 
     /* 构造方法 */
     constructor(capacity) {
@@ -43,7 +43,7 @@ class ArrayDeque {
     /* 队首入队 */
     pushFirst(num) {
         if (this.#queSize === this.capacity()) {
-            console.log("双向队列已满");
+            console.log('双向队列已满');
             return;
         }
         // 队首指针向左移动一位
@@ -57,7 +57,7 @@ class ArrayDeque {
     /* 队尾入队 */
     pushLast(num) {
         if (this.#queSize === this.capacity()) {
-            console.log("双向队列已满");
+            console.log('双向队列已满');
             return;
         }
         // 计算尾指针，指向队尾索引 + 1
@@ -85,15 +85,13 @@ class ArrayDeque {
 
     /* 访问队首元素 */
     peekFirst() {
-        if (this.isEmpty())
-            throw new Error("The Deque Is Empty.");
+        if (this.isEmpty()) throw new Error('The Deque Is Empty.');
         return this.#nums[this.#front];
     }
 
     /* 访问队尾元素 */
     peekLast() {
-        if (this.isEmpty())
-            throw new Error("The Deque Is Empty.");
+        if (this.isEmpty()) throw new Error('The Deque Is Empty.');
         // 计算尾元素索引
         const last = this.index(this.#front + this.#queSize - 1);
         return this.#nums[last];
@@ -117,30 +115,42 @@ const deque = new ArrayDeque(capacity);
 deque.pushLast(3);
 deque.pushLast(2);
 deque.pushLast(5);
-console.log("双向队列 deque = [" + deque.toArray() + "]");
+console.log('双向队列 deque = [' + deque.toArray() + ']');
 
 /* 访问元素 */
 const peekFirst = deque.peekFirst();
-console.log("队首元素 peekFirst = " + peekFirst);
+console.log('队首元素 peekFirst = ' + peekFirst);
 const peekLast = deque.peekLast();
-console.log("队尾元素 peekLast = " + peekLast);
+console.log('队尾元素 peekLast = ' + peekLast);
 
 /* 元素入队 */
 deque.pushLast(4);
-console.log("元素 4 队尾入队后 deque = [" + deque.toArray() + "]");
+console.log('元素 4 队尾入队后 deque = [' + deque.toArray() + ']');
 deque.pushFirst(1);
-console.log("元素 1 队首入队后 deque = [" + deque.toArray() + "]");
+console.log('元素 1 队首入队后 deque = [' + deque.toArray() + ']');
 
 /* 元素出队 */
 const popLast = deque.popLast();
-console.log("队尾出队元素 = " + popLast + "，队尾出队后 deque = [" + deque.toArray() + "]");
+console.log(
+    '队尾出队元素 = ' +
+        popLast +
+        '，队尾出队后 deque = [' +
+        deque.toArray() +
+        ']'
+);
 const popFirst = deque.popFirst();
-console.log("队首出队元素 = " + popFirst + "，队首出队后 deque = [" + deque.toArray()+ "]");
+console.log(
+    '队首出队元素 = ' +
+        popFirst +
+        '，队首出队后 deque = [' +
+        deque.toArray() +
+        ']'
+);
 
 /* 获取双向队列的长度 */
 const size = deque.size();
-console.log("双向队列长度 size = " + size);
+console.log('双向队列长度 size = ' + size);
 
 /* 判断双向队列是否为空 */
 const isEmpty = deque.isEmpty();
-console.log("双向队列是否为空 = " + isEmpty);
+console.log('双向队列是否为空 = ' + isEmpty);

codes/javascript/chapter_stack_and_queue/array_queue.js

@@ -6,9 +6,9 @@
 
 /* 基于环形数组实现的队列 */
 class ArrayQueue {
-    #nums;         // 用于存储队列元素的数组
-    #front = 0;    // 队首指针，指向队首元素
-    #queSize = 0;  // 队列长度
+    #nums; // 用于存储队列元素的数组
+    #front = 0; // 队首指针，指向队首元素
+    #queSize = 0; // 队列长度
 
     constructor(capacity) {
         this.#nums = new Array(capacity);
@@ -32,7 +32,7 @@ class ArrayQueue {
     /* 入队 */
     push(num) {
         if (this.size == this.capacity) {
-            console.log("队列已满");
+            console.log('队列已满');
             return;
         }
         // 计算尾指针，指向队尾索引 + 1
@@ -54,8 +54,7 @@ class ArrayQueue {
 
     /* 访问队首元素 */
     peek() {
-        if (this.empty())
-            throw new Error("队列为空");
+        if (this.empty()) throw new Error('队列为空');
         return this.#nums[this.#front];
     }
 
@@ -70,7 +69,6 @@ class ArrayQueue {
     }
 }
 
-
 /* Driver Code */
 /* 初始化队列 */
 const capacity = 10;
@@ -82,27 +80,27 @@ queue.push(3);
 queue.push(2);
 queue.push(5);
 queue.push(4);
-console.log("队列 queue =", queue.toArray());
+console.log('队列 queue =', queue.toArray());
 
 /* 访问队首元素 */
 const peek = queue.peek();
-console.log("队首元素 peek = " + peek);
+console.log('队首元素 peek = ' + peek);
 
 /* 元素出队 */
 const pop = queue.pop();
-console.log("出队元素 pop = " + pop + "，出队后 queue =", queue.toArray());
+console.log('出队元素 pop = ' + pop + '，出队后 queue =', queue.toArray());
 
 /* 获取队列的长度 */
 const size = queue.size;
-console.log("队列长度 size = " + size);
+console.log('队列长度 size = ' + size);
 
 /* 判断队列是否为空 */
 const empty = queue.empty();
-console.log("队列是否为空 = " + empty);
+console.log('队列是否为空 = ' + empty);
 
 /* 测试环形数组 */
 for (let i = 0; i < 10; i++) {
     queue.push(i);
     queue.pop();
-    console.log("第 " + i + " 轮入队 + 出队后 queue =", queue.toArray());
+    console.log('第 ' + i + ' 轮入队 + 出队后 queue =', queue.toArray());
 }

codes/javascript/chapter_stack_and_queue/array_stack.js

@@ -4,14 +4,13 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-
 /* 基于数组实现的栈 */
 class ArrayStack {
     #stack;
     constructor() {
         this.#stack = [];
     }
-    
+
     /* 获取栈的长度 */
     get size() {
         return this.#stack.length;
@@ -29,15 +28,13 @@ class ArrayStack {
 
     /* 出栈 */
     pop() {
-        if (this.empty())
-            throw new Error("栈为空");
+        if (this.empty()) throw new Error('栈为空');
         return this.#stack.pop();
     }
 
     /* 访问栈顶元素 */
     top() {
-        if (this.empty())
-            throw new Error("栈为空");
+        if (this.empty()) throw new Error('栈为空');
         return this.#stack[this.#stack.length - 1];
     }
 
@@ -45,8 +42,7 @@ class ArrayStack {
     toArray() {
         return this.#stack;
     }
-};
-
+}
 
 /* Driver Code */
 /* 初始化栈 */
@@ -58,22 +54,22 @@ stack.push(3);
 stack.push(2);
 stack.push(5);
 stack.push(4);
-console.log("栈 stack = ");
+console.log('栈 stack = ');
 console.log(stack.toArray());
 
 /* 访问栈顶元素 */
 const top = stack.top();
-console.log("栈顶元素 top = " + top);
+console.log('栈顶元素 top = ' + top);
 
 /* 元素出栈 */
 const pop = stack.pop();
-console.log("出栈元素 pop = " + pop + "，出栈后 stack = ");
+console.log('出栈元素 pop = ' + pop + '，出栈后 stack = ');
 console.log(stack.toArray());
 
 /* 获取栈的长度 */
 const size = stack.size;
-console.log("栈的长度 size = " + size);
+console.log('栈的长度 size = ' + size);
 
 /* 判断是否为空 */
 const empty = stack.empty();
-console.log("栈是否为空 = " + empty);
+console.log('栈是否为空 = ' + empty);

codes/javascript/chapter_stack_and_queue/deque.js

@@ -16,25 +16,29 @@ deque.push(4);
 // 请注意，由于是数组，unshift() 方法的时间复杂度为 O(n)
 deque.unshift(3);
 deque.unshift(1);
-console.log("双向队列 deque = ", deque);
+console.log('双向队列 deque = ', deque);
 
 /* 访问元素 */
 const peekFirst = deque[0];
-console.log("队首元素 peekFirst = " + peekFirst);
+console.log('队首元素 peekFirst = ' + peekFirst);
 const peekLast = deque[deque.length - 1];
-console.log("队尾元素 peekLast = " + peekLast);
+console.log('队尾元素 peekLast = ' + peekLast);
 
 /* 元素出队 */
 // 请注意，由于是数组，shift() 方法的时间复杂度为 O(n)
 const popFront = deque.shift();
-console.log("队首出队元素 popFront = " + popFront + "，队首出队后 deque = " + deque);
+console.log(
+    '队首出队元素 popFront = ' + popFront + '，队首出队后 deque = ' + deque
+);
 const popBack = deque.pop();
-console.log("队尾出队元素 popBack = " + popBack + "，队尾出队后 deque = " + deque);
+console.log(
+    '队尾出队元素 popBack = ' + popBack + '，队尾出队后 deque = ' + deque
+);
 
 /* 获取双向队列的长度 */
 const size = deque.length;
-console.log("双向队列长度 size = " + size);
+console.log('双向队列长度 size = ' + size);
 
 /* 判断双向队列是否为空 */
 const isEmpty = size === 0;
-console.log("双向队列是否为空 = " + isEmpty);
+console.log('双向队列是否为空 = ' + isEmpty);

codes/javascript/chapter_stack_and_queue/linkedlist_deque.js

@@ -6,10 +6,10 @@
 
 /* 双向链表节点 */
 class ListNode {
-    prev;   // 前驱节点引用 (指针)
-    next;   // 后继节点引用 (指针)
-    val;    // 节点值
-    
+    prev; // 前驱节点引用 (指针)
+    next; // 后继节点引用 (指针)
+    val; // 节点值
+
     constructor(val) {
         this.val = val;
         this.next = null;
@@ -19,9 +19,9 @@ class ListNode {
 
 /* 基于双向链表实现的双向队列 */
 class LinkedListDeque {
-    #front;  // 头节点 front
-    #rear;   // 尾节点 rear
-    #queSize;    // 双向队列的长度
+    #front; // 头节点 front
+    #rear; // 尾节点 rear
+    #queSize; // 双向队列的长度
 
     constructor() {
         this.#front = null;
@@ -73,7 +73,7 @@ class LinkedListDeque {
             temp.next = null;
             this.#rear.prev = null;
         }
-        this.#rear = temp;   // 更新尾节点
+        this.#rear = temp; // 更新尾节点
         this.#queSize--;
         return value;
     }
@@ -90,7 +90,7 @@ class LinkedListDeque {
             temp.prev = null;
             this.#front.next = null;
         }
-        this.#front = temp;   // 更新头节点
+        this.#front = temp; // 更新头节点
         this.#queSize--;
         return value;
     }
@@ -123,7 +123,7 @@ class LinkedListDeque {
             arr.push(temp.val);
             temp = temp.next;
         }
-        console.log("[" + arr.join(", ") + "]");
+        console.log('[' + arr.join(', ') + ']');
     }
 }
 
@@ -133,35 +133,35 @@ const linkedListDeque = new LinkedListDeque();
 linkedListDeque.pushLast(3);
 linkedListDeque.pushLast(2);
 linkedListDeque.pushLast(5);
-console.log("双向队列 linkedListDeque = ");
+console.log('双向队列 linkedListDeque = ');
 linkedListDeque.print();
 
 /* 访问元素 */
 const peekFirst = linkedListDeque.peekFirst();
-console.log("队首元素 peekFirst = " + peekFirst);
+console.log('队首元素 peekFirst = ' + peekFirst);
 const peekLast = linkedListDeque.peekLast();
-console.log("队尾元素 peekLast = " + peekLast);
+console.log('队尾元素 peekLast = ' + peekLast);
 
 /* 元素入队 */
 linkedListDeque.pushLast(4);
-console.log("元素 4 队尾入队后 linkedListDeque = ");
+console.log('元素 4 队尾入队后 linkedListDeque = ');
 linkedListDeque.print();
 linkedListDeque.pushFirst(1);
-console.log("元素 1 队首入队后 linkedListDeque = ");
+console.log('元素 1 队首入队后 linkedListDeque = ');
 linkedListDeque.print();
 
 /* 元素出队 */
 const popLast = linkedListDeque.popLast();
-console.log("队尾出队元素 = " + popLast + "，队尾出队后 linkedListDeque = ");
+console.log('队尾出队元素 = ' + popLast + '，队尾出队后 linkedListDeque = ');
 linkedListDeque.print();
 const popFirst = linkedListDeque.popFirst();
-console.log("队首出队元素 = " + popFirst + "，队首出队后 linkedListDeque = ");
+console.log('队首出队元素 = ' + popFirst + '，队首出队后 linkedListDeque = ');
 linkedListDeque.print();
 
 /* 获取双向队列的长度 */
 const size = linkedListDeque.size();
-console.log("双向队列长度 size = " + size);
+console.log('双向队列长度 size = ' + size);
 
 /* 判断双向队列是否为空 */
 const isEmpty = linkedListDeque.isEmpty();
-console.log("双向队列是否为空 = " + isEmpty);
+console.log('双向队列是否为空 = ' + isEmpty);

codes/javascript/chapter_stack_and_queue/linkedlist_queue.js

@@ -4,12 +4,12 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-const { ListNode } = require("../modules/ListNode");
+const { ListNode } = require('../modules/ListNode');
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {
-    #front;  // 头节点 #front
-    #rear;   // 尾节点 #rear
+    #front; // 头节点 #front
+    #rear; // 尾节点 #rear
     #queSize = 0;
 
     constructor() {
@@ -54,8 +54,7 @@ class LinkedListQueue {
 
     /* 访问队首元素 */
     peek() {
-        if (this.size === 0)
-            throw new Error("队列为空");
+        if (this.size === 0) throw new Error('队列为空');
         return this.#front.val;
     }
 
@@ -71,8 +70,6 @@ class LinkedListQueue {
     }
 }
 
-
-
 /* Driver Code */
 /* 初始化队列 */
 const queue = new LinkedListQueue();
@@ -83,20 +80,20 @@ queue.push(3);
 queue.push(2);
 queue.push(5);
 queue.push(4);
-console.log("队列 queue = " + queue.toArray());
+console.log('队列 queue = ' + queue.toArray());
 
 /* 访问队首元素 */
 const peek = queue.peek();
-console.log("队首元素 peek = " + peek);
+console.log('队首元素 peek = ' + peek);
 
 /* 元素出队 */
 const pop = queue.pop();
-console.log("出队元素 pop = " + pop + "，出队后 queue = " + queue.toArray());
+console.log('出队元素 pop = ' + pop + '，出队后 queue = ' + queue.toArray());
 
 /* 获取队列的长度 */
 const size = queue.size;
-console.log("队列长度 size = " + size);
+console.log('队列长度 size = ' + size);
 
 /* 判断队列是否为空 */
 const isEmpty = queue.isEmpty();
-console.log("队列是否为空 = " + isEmpty);
+console.log('队列是否为空 = ' + isEmpty);

codes/javascript/chapter_stack_and_queue/linkedlist_stack.js

@@ -4,12 +4,12 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-const { ListNode } = require("../modules/ListNode");
+const { ListNode } = require('../modules/ListNode');
 
 /* 基于链表实现的栈 */
 class LinkedListStack {
-    #stackPeek;     // 将头节点作为栈顶
-    #stkSize = 0;   // 栈的长度
+    #stackPeek; // 将头节点作为栈顶
+    #stkSize = 0; // 栈的长度
 
     constructor() {
         this.#stackPeek = null;
@@ -43,8 +43,7 @@ class LinkedListStack {
 
     /* 访问栈顶元素 */
     peek() {
-        if (!this.#stackPeek)
-            throw new Error("栈为空");
+        if (!this.#stackPeek) throw new Error('栈为空');
         return this.#stackPeek.val;
     }
 
@@ -70,20 +69,20 @@ stack.push(3);
 stack.push(2);
 stack.push(5);
 stack.push(4);
-console.log("栈 stack = " + stack.toArray());
+console.log('栈 stack = ' + stack.toArray());
 
 /* 访问栈顶元素 */
 const peek = stack.peek();
-console.log("栈顶元素 peek = " + peek);
+console.log('栈顶元素 peek = ' + peek);
 
 /* 元素出栈 */
 const pop = stack.pop();
-console.log("出栈元素 pop = " + pop + "，出栈后 stack = " + stack.toArray());
+console.log('出栈元素 pop = ' + pop + '，出栈后 stack = ' + stack.toArray());
 
 /* 获取栈的长度 */
 const size = stack.size;
-console.log("栈的长度 size = " + size);
+console.log('栈的长度 size = ' + size);
 
 /* 判断是否为空 */
 const isEmpty = stack.isEmpty();
-console.log("栈是否为空 = " + isEmpty);
+console.log('栈是否为空 = ' + isEmpty);

codes/javascript/chapter_stack_and_queue/queue.js

@@ -15,21 +15,21 @@ queue.push(3);
 queue.push(2);
 queue.push(5);
 queue.push(4);
-console.log("队列 queue =", queue);
+console.log('队列 queue =', queue);
 
 /* 访问队首元素 */
 const peek = queue[0];
-console.log("队首元素 peek =", peek);
+console.log('队首元素 peek =', peek);
 
 /* 元素出队 */
 // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
 const pop = queue.shift();
-console.log("出队元素 pop =", pop, "，出队后 queue = ", queue);
+console.log('出队元素 pop =', pop, '，出队后 queue = ', queue);
 
 /* 获取队列的长度 */
 const size = queue.length;
-console.log("队列长度 size =", size);
+console.log('队列长度 size =', size);
 
 /* 判断队列是否为空 */
 const isEmpty = queue.length === 0;
-console.log("队列是否为空 = ", isEmpty);
+console.log('队列是否为空 = ', isEmpty);

codes/javascript/chapter_stack_and_queue/stack.js

@@ -6,7 +6,7 @@
 
 /* Driver Code */
 /* 初始化栈 */
-// Javascript 没有内置的栈类，可以把 Array 当作栈来使用 
+// Javascript 没有内置的栈类，可以把 Array 当作栈来使用
 const stack = [];
 
 /* 元素入栈 */
@@ -15,21 +15,21 @@ stack.push(3);
 stack.push(2);
 stack.push(5);
 stack.push(4);
-console.log("栈 stack =", stack);
+console.log('栈 stack =', stack);
 
 /* 访问栈顶元素 */
 const peek = stack[stack.length - 1];
-console.log("栈顶元素 peek =", peek);
+console.log('栈顶元素 peek =', peek);
 
 /* 元素出栈 */
 const pop = stack.pop();
-console.log("出栈元素 pop =", pop);
-console.log("出栈后 stack =", stack);
+console.log('出栈元素 pop =', pop);
+console.log('出栈后 stack =', stack);
 
 /* 获取栈的长度 */
 const size = stack.length;
-console.log("栈的长度 size =", size);
+console.log('栈的长度 size =', size);
 
 /* 判断是否为空 */
 const isEmpty = stack.length === 0;
-console.log("栈是否为空 =", isEmpty);
+console.log('栈是否为空 =', isEmpty);