Update JavaScript and TypeScript codes for all chapters, rename JavaScript and TypeScript import folder to modules (#402)

* Update JavaScript and TypeScript codes

* Rename JavaScript and TypeScript import folder to modules

codes/javascript/chapter_array_and_linkedlist/linked_list.js

@@ -4,8 +4,8 @@
  * Author: IsChristina (christinaxia77@foxmail.com), Justin (xiefahit@gmail.com)
  */
 
-const { printLinkedList } = require("../include/PrintUtil");
-const { ListNode } = require("../include/ListNode");
+const { printLinkedList } = require("../modules/PrintUtil");
+const { ListNode } = require("../modules/ListNode");
 
 /* 在链表的结点 n0 之后插入结点 P */
 function insert(n0, P) {

codes/javascript/chapter_computational_complexity/space_complexity.js

@@ -4,9 +4,9 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-const { ListNode } = require('../include/ListNode');
-const { TreeNode } = require('../include/TreeNode');
-const { printTree } = require('../include/PrintUtil');
+const { ListNode } = require('../modules/ListNode');
+const { TreeNode } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
 
 /* 函数 */
 function constFunc() {

codes/javascript/chapter_graph/graph_adjacency_list.js

@@ -4,7 +4,7 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-const { Vertex } = require('../include/Vertex')
+const { Vertex } = require('../modules/Vertex')
 
 /* 基于邻接表实现的无向图类 */
 class GraphAdjList {

codes/javascript/chapter_graph/graph_adjacency_matrix.js

@@ -92,7 +92,7 @@ class GraphAdjMat {
     }
 }
 
-
+/* Driver Code */
 /* 初始化无向图 */
 // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
 const vertices = [1, 3, 2, 5, 4];

codes/javascript/chapter_graph/graph_bfs.js

@@ -4,10 +4,8 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
-
 const { GraphAdjList } = require('./graph_adjacency_list');
-const { Vertex } = require('../include/Vertex');
-
+const { Vertex } = require('../modules/Vertex');
 
 /* 广度优先遍历 BFS */
 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
@@ -36,7 +34,6 @@ function graphBFS(graph, startVet) {
     return res;
 }
 
-
 /* Driver Code */
 /* 初始化无向图 */
 const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

codes/javascript/chapter_graph/graph_dfs.js

@@ -4,8 +4,7 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
-
-const { Vertex } = require('../include/Vertex');
+const { Vertex } = require('../modules/Vertex');
 const { GraphAdjList } = require('./graph_adjacency_list');
 
 /* 深度优先遍历 DFS */
@@ -34,7 +33,6 @@ function graphDFS(graph, startVet) {
     return res;
 }
 
-
 /* Driver Code */
 /* 初始化无向图 */
 const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6]);

codes/javascript/chapter_heap/my_heap.js

@@ -4,7 +4,7 @@
  * Author: what-is-me (whatisme@outlook.jp)
  */
 
-const { printHeap } = require("../include/PrintUtil");
+const { printHeap } = require("../modules/PrintUtil");
 
 /* 最大堆类 */
 class MaxHeap {

codes/javascript/chapter_searching/binary_search.js

@@ -10,7 +10,7 @@ function binarySearch(nums, target) {
     let i = 0, j = nums.length - 1;
     // 循环，当搜索区间为空时跳出（当 i > j 时为空）
     while (i <= j) {
-        let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
+        const m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
         if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
         else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m-1] 中
@@ -28,7 +28,7 @@ function binarySearch1(nums, target) {
     let i = 0, j = nums.length;
     // 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while (i < j) {
-        let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
+        const m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
         if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j) 中
             i = m + 1;
         else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m) 中
@@ -41,11 +41,11 @@ function binarySearch1(nums, target) {
 }
 
 /* Driver Code */
-var target = 6;
-var nums = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92];
+const target = 6;
+const nums = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92];
 
 /* 二分查找（双闭区间） */
-var index = binarySearch(nums, target);
+let index = binarySearch(nums, target);
 console.log("目标元素 6 的索引 = " + index);
 
 /* 二分查找（左闭右开） */

codes/javascript/chapter_searching/hashing_search.js

@@ -4,7 +4,7 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
-const { ListNode, arrToLinkedList } = require("../include/ListNode");
+const { arrToLinkedList } = require("../modules/ListNode");
 
 /* 哈希查找（数组） */
 function hashingSearchArray(map, target) {

codes/javascript/chapter_searching/linear_search.js

@@ -4,7 +4,7 @@
  * Author: JoseHung (szhong@link.cuhk.edu.hk)
  */
 
-const { ListNode, arrToLinkedList } = require("../include/ListNode");
+const { ListNode, arrToLinkedList } = require("../modules/ListNode");
 
 /* 线性查找（数组） */
 function linearSearchArray(nums, target) {

codes/javascript/chapter_sorting/bubble_sort.js

@@ -1,5 +1,5 @@
 /**
- * File: quick_sort.js
+ * File: bubble_sort.js
  * Created Time: 2022-12-01
  * Author: IsChristina (christinaxia77@foxmail.com)
  */

codes/javascript/chapter_sorting/insertion_sort.js

@@ -1,5 +1,5 @@
 /**
- * File: quick_sort.js
+ * File: insertion_sort.js
  * Created Time: 2022-12-01
  * Author: IsChristina (christinaxia77@foxmail.com)
  */

codes/javascript/chapter_sorting/merge_sort.js

@@ -1,5 +1,5 @@
 /**
- * File: quick_sort.js
+ * File: merge_sort.js
  * Created Time: 2022-12-01
  * Author: IsChristina (christinaxia77@foxmail.com)
  */
@@ -44,6 +44,6 @@ function mergeSort(nums, left, right) {
 }
 
 /* Driver Code */
-const nums = [ 7, 3, 2, 6, 0, 1, 5, 4 ]
-mergeSort(nums, 0, nums.length - 1)
-console.log('归并排序完成后 nums =', nums)
+const nums = [7, 3, 2, 6, 0, 1, 5, 4];
+mergeSort(nums, 0, nums.length - 1);
+console.log('归并排序完成后 nums =', nums);

codes/javascript/chapter_stack_and_queue/array_stack.js

@@ -7,49 +7,48 @@
 
 /* 基于数组实现的栈 */
 class ArrayStack {
-    stack;
+    #stack;
     constructor() {
-        this.stack = [];
+        this.#stack = [];
     }
     
     /* 获取栈的长度 */
     get size() {
-        return this.stack.length;
+        return this.#stack.length;
     }
 
     /* 判断栈是否为空 */
     empty() {
-        return this.stack.length === 0;
+        return this.#stack.length === 0;
     }
 
     /* 入栈 */
     push(num) {
-        this.stack.push(num);
+        this.#stack.push(num);
     }
 
     /* 出栈 */
     pop() {
         if (this.empty())
             throw new Error("栈为空");
-        return this.stack.pop();
+        return this.#stack.pop();
     }
 
     /* 访问栈顶元素 */
     top() {
         if (this.empty())
             throw new Error("栈为空");
-        return this.stack[this.stack.length - 1];
+        return this.#stack[this.#stack.length - 1];
     }
 
     /* 返回 Array */
     toArray() {
-        return this.stack;
+        return this.#stack;
     }
 };
 
 
 /* Driver Code */
-
 /* 初始化栈 */
 const stack = new ArrayStack();
 

codes/javascript/chapter_stack_and_queue/deque.js

@@ -4,6 +4,7 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
+/* Driver Code */
 /* 初始化双向队列 */
 // JavaScript 没有内置的双端队列，只能把 Array 当作双端队列来使用
 const deque = [];

codes/javascript/chapter_stack_and_queue/linkedlist_deque.js

@@ -19,106 +19,106 @@ class ListNode {
 
 /* 基于双向链表实现的双向队列 */
 class LinkedListDeque {
-    front;  // 头结点 front
-    rear;   // 尾结点 rear
-    len;    // 双向队列的长度
+    #front;  // 头结点 front
+    #rear;   // 尾结点 rear
+    #queSize;    // 双向队列的长度
 
     constructor() {
-        this.front = null;
-        this.rear = null;
-        this.len = 0;
+        this.#front = null;
+        this.#rear = null;
+        this.#queSize = 0;
     }
 
     /* 队尾入队操作 */
     pushLast(val) {
         const node = new ListNode(val);
         // 若链表为空，则令 front, rear 都指向 node
-        if (this.len === 0) {
-            this.front = node;
-            this.rear = node;
+        if (this.#queSize === 0) {
+            this.#front = node;
+            this.#rear = node;
         } else {
             // 将 node 添加至链表尾部
-            this.rear.next = node;
-            node.prev = this.rear;
-            this.rear = node; // 更新尾结点
+            this.#rear.next = node;
+            node.prev = this.#rear;
+            this.#rear = node; // 更新尾结点
         }
-        this.len++;
+        this.#queSize++;
     }
 
     /* 队首入队操作 */
     pushFirst(val) {
         const node = new ListNode(val);
         // 若链表为空，则令 front, rear 都指向 node
-        if (this.len === 0) {
-            this.front = node;
-            this.rear = node;
+        if (this.#queSize === 0) {
+            this.#front = node;
+            this.#rear = node;
         } else {
             // 将 node 添加至链表头部
-            this.front.prev = node;
-            node.next = this.front;
-            this.front = node; // 更新头结点
+            this.#front.prev = node;
+            node.next = this.#front;
+            this.#front = node; // 更新头结点
         }
-        this.len++;
+        this.#queSize++;
     }
 
     /* 队尾出队操作 */
     pollLast() {
-        if (this.len === 0) {
+        if (this.#queSize === 0) {
             return null;
         }
-        const value = this.rear.val; // 存储尾结点值
+        const value = this.#rear.val; // 存储尾结点值
         // 删除尾结点
-        let temp = this.rear.prev;
+        let temp = this.#rear.prev;
         if (temp !== null) {
             temp.next = null;
-            this.rear.prev = null;
+            this.#rear.prev = null;
         }
-        this.rear = temp;   // 更新尾结点
-        this.len--;
+        this.#rear = temp;   // 更新尾结点
+        this.#queSize--;
         return value;
     }
 
     /* 队首出队操作 */
     pollFirst() {
-        if (this.len === 0) {
+        if (this.#queSize === 0) {
             return null;
         }
-        const value = this.front.val; // 存储尾结点值
+        const value = this.#front.val; // 存储尾结点值
         // 删除头结点
-        let temp = this.front.next;
+        let temp = this.#front.next;
         if (temp !== null) {
             temp.prev = null;
-            this.front.next = null;
+            this.#front.next = null;
         }
-        this.front = temp;   // 更新头结点
-        this.len--;
+        this.#front = temp;   // 更新头结点
+        this.#queSize--;
         return value;
     }
 
     /* 访问队尾元素 */
     peekLast() {
-        return this.len === 0 ? null : this.rear.val;
+        return this.#queSize === 0 ? null : this.#rear.val;
     }
 
     /* 访问队首元素 */
     peekFirst() {
-        return this.len === 0 ? null : this.front.val;
+        return this.#queSize === 0 ? null : this.#front.val;
     }
 
     /* 获取双向队列的长度 */
     size() {
-        return this.len;
+        return this.#queSize;
     }
 
     /* 判断双向队列是否为空 */
     isEmpty() {
-        return this.len === 0;
+        return this.#queSize === 0;
     }
 
     /* 打印双向队列 */
     print() {
         const arr = [];
-        let temp = this.front;
+        let temp = this.#front;
         while (temp !== null) {
             arr.push(temp.val);
             temp = temp.next;
@@ -127,6 +127,7 @@ class LinkedListDeque {
     }
 }
 
+/* Driver Code */
 /* 初始化双向队列 */
 const linkedListDeque = new LinkedListDeque();
 linkedListDeque.pushLast(3);

codes/javascript/chapter_stack_and_queue/linkedlist_queue.js

@@ -4,7 +4,7 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-const { ListNode } = require("../include/ListNode");
+const { ListNode } = require("../modules/ListNode");
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {

codes/javascript/chapter_stack_and_queue/linkedlist_stack.js

@@ -4,7 +4,7 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-const { ListNode } = require("../include/ListNode");
+const { ListNode } = require("../modules/ListNode");
 
 /* 基于链表实现的栈 */
 class LinkedListStack {
@@ -60,7 +60,7 @@ class LinkedListStack {
     }
 }
 
-
+/* Driver Code */
 /* 初始化栈 */
 const stack = new LinkedListStack();
 

codes/javascript/chapter_stack_and_queue/queue.js

@@ -4,7 +4,6 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-
 /* Driver Code */
 /* 初始化队列 */
 // JavaScript 没有内置的队列，可以把 Array 当作队列来使用
@@ -16,16 +15,21 @@ queue.push(3);
 queue.push(2);
 queue.push(5);
 queue.push(4);
+console.log("队列 queue =", queue);
 
 /* 访问队首元素 */
 const peek = queue[0];
+console.log("队首元素 peek =", peek);
 
 /* 元素出队 */
 // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
 const poll = queue.shift();
+console.log("出队元素 poll =", poll, "，出队后 queue = ", queue);
 
 /* 获取队列的长度 */
 const size = queue.length;
+console.log("队列长度 size =", size);
 
 /* 判断队列是否为空 */
-const empty = queue.length === 0;
+const isEmpty = queue.length === 0;
+console.log("队列是否为空 = ", isEmpty);

codes/javascript/chapter_stack_and_queue/stack.js

@@ -4,7 +4,6 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-
 /* Driver Code */
 /* 初始化栈 */
 // Javascript 没有内置的栈类，可以把 Array 当作栈来使用 
@@ -16,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 is_empty = stack.length === 0;
-console.log("栈是否为空 =", is_empty)
+const isEmpty = stack.length === 0;
+console.log("栈是否为空 =", isEmpty);

codes/javascript/chapter_tree/avl_tree.js

@@ -4,8 +4,8 @@
  * Author: what-is-me (whatisme@outlook.jp)
  */
 
-const { TreeNode } = require("../include/TreeNode");
-const { printTree } = require("../include/PrintUtil");
+const { TreeNode } = require("../modules/TreeNode");
+const { printTree } = require("../modules/PrintUtil");
 
 /* AVL 树*/
 class AVLTree {
@@ -21,7 +21,7 @@ class AVLTree {
     }
 
     /* 更新结点高度 */
-    updateHeight(node) {
+    #updateHeight(node) {
         // 结点高度等于最高子树高度 + 1
         node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
     }
@@ -35,57 +35,57 @@ class AVLTree {
     }
 
     /* 右旋操作 */
-    rightRotate(node) {
+    #rightRotate(node) {
         const child = node.left;
         const grandChild = child.right;
         // 以 child 为原点，将 node 向右旋转
         child.right = node;
         node.left = grandChild;
         // 更新结点高度
-        this.updateHeight(node);
-        this.updateHeight(child);
+        this.#updateHeight(node);
+        this.#updateHeight(child);
         // 返回旋转后子树的根结点
         return child;
     }
 
     /* 左旋操作 */
-    leftRotate(node) {
+    #leftRotate(node) {
         const child = node.right;
         const grandChild = child.left;
         // 以 child 为原点，将 node 向左旋转
         child.left = node;
         node.right = grandChild;
         // 更新结点高度
-        this.updateHeight(node);
-        this.updateHeight(child);
+        this.#updateHeight(node);
+        this.#updateHeight(child);
         // 返回旋转后子树的根结点
         return child;
     }
 
     /* 执行旋转操作，使该子树重新恢复平衡 */
-    rotate(node) {
+    #rotate(node) {
         // 获取结点 node 的平衡因子
         const balanceFactor = this.balanceFactor(node);
         // 左偏树
         if (balanceFactor > 1) {
             if (this.balanceFactor(node.left) >= 0) {
                 // 右旋
-                return this.rightRotate(node);
+                return this.#rightRotate(node);
             } else {
                 // 先左旋后右旋
-                node.left = this.leftRotate(node.left);
-                return this.rightRotate(node);
+                node.left = this.#leftRotate(node.left);
+                return this.#rightRotate(node);
             }
         }
         // 右偏树
         if (balanceFactor < -1) {
             if (this.balanceFactor(node.right) <= 0) {
                 // 左旋
-                return this.leftRotate(node);
+                return this.#leftRotate(node);
             } else {
                 // 先右旋后左旋
-                node.right = this.rightRotate(node.right);
-                return this.leftRotate(node);
+                node.right = this.#rightRotate(node.right);
+                return this.#leftRotate(node);
             }
         }
         // 平衡树，无需旋转，直接返回
@@ -94,36 +94,36 @@ class AVLTree {
 
     /* 插入结点 */
     insert(val) {
-        this.root = this.insertHelper(this.root, val);
+        this.root = this.#insertHelper(this.root, val);
         return this.root;
     }
 
     /* 递归插入结点（辅助方法） */
-    insertHelper(node, val) {
+    #insertHelper(node, val) {
         if (node === null) return new TreeNode(val);
         /* 1. 查找插入位置，并插入结点 */
-        if (val < node.val) node.left = this.insertHelper(node.left, val);
-        else if (val > node.val) node.right = this.insertHelper(node.right, val);
+        if (val < node.val) node.left = this.#insertHelper(node.left, val);
+        else if (val > node.val) node.right = this.#insertHelper(node.right, val);
         else return node; // 重复结点不插入，直接返回
-        this.updateHeight(node); // 更新结点高度
+        this.#updateHeight(node); // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
-        node = this.rotate(node);
+        node = this.#rotate(node);
         // 返回子树的根结点
         return node;
     }
 
     /* 删除结点 */
     remove(val) {
-        this.root = this.removeHelper(this.root, val);
+        this.root = this.#removeHelper(this.root, val);
         return this.root;
     }
 
     /* 递归删除结点（辅助方法） */
-    removeHelper(node, val) {
+    #removeHelper(node, val) {
         if (node === null) return null;
         /* 1. 查找结点，并删除之 */
-        if (val < node.val) node.left = this.removeHelper(node.left, val);
-        else if (val > node.val) node.right = this.removeHelper(node.right, val);
+        if (val < node.val) node.left = this.#removeHelper(node.left, val);
+        else if (val > node.val) node.right = this.#removeHelper(node.right, val);
         else {
             if (node.left === null || node.right === null) {
                 const child = node.left !== null ? node.left : node.right;
@@ -133,20 +133,20 @@ class AVLTree {
                 else node = child;
             } else {
                 // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                const temp = this.getInOrderNext(node.right);
-                node.right = this.removeHelper(node.right, temp.val);
+                const temp = this.#getInOrderNext(node.right);
+                node.right = this.#removeHelper(node.right, temp.val);
                 node.val = temp.val;
             }
         }
-        this.updateHeight(node); // 更新结点高度
+        this.#updateHeight(node); // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
-        node = this.rotate(node);
+        node = this.#rotate(node);
         // 返回子树的根结点
         return node;
     }
 
     /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
-    getInOrderNext(node) {
+    #getInOrderNext(node) {
         if (node === null) return node;
         // 循环访问左子结点，直到叶结点时为最小结点，跳出
         while (node.left !== null) {

codes/javascript/chapter_tree/binary_search_tree.js

@@ -1,14 +1,14 @@
 /**
- * File: binary_tree.js
+ * File: binary_search_tree.js
  * Created Time: 2022-12-04
  * Author: IsChristina (christinaxia77@foxmail.com)
  */
 
-const Tree = require("../include/TreeNode");
-const { printTree } = require("../include/PrintUtil");
+const { TreeNode } = require("../modules/TreeNode");
+const { printTree } = require("../modules/PrintUtil");
 
 /* 二叉搜索树 */
-var root;
+let root;
 
 function BinarySearchTree(nums) {
     nums.sort((a, b) => { return a - b }); // 排序数组
@@ -25,7 +25,7 @@ function buildTree(nums, i, j) {
     if (i > j) return null;
     // 将数组中间结点作为根结点
     let mid = Math.floor((i + j) / 2);
-    let root = new Tree.TreeNode(nums[mid]);
+    let root = new TreeNode(nums[mid]);
     // 递归建立左子树和右子树
     root.left = buildTree(nums, i, mid - 1);
     root.right = buildTree(nums, mid + 1, j);
@@ -64,7 +64,7 @@ function insert(num) {
         else cur = cur.left;
     }
     // 插入结点 val
-    let node = new Tree.TreeNode(num);
+    let node = new TreeNode(num);
     if (pre.val < num) pre.right = node;
     else pre.left = node;
     return node;
@@ -120,7 +120,7 @@ function getInOrderNext(root) {
 
 /* Driver Code */
 /* 初始化二叉搜索树 */
-var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
 BinarySearchTree(nums);
 console.log("\n初始化的二叉树为\n");
 printTree(getRoot());

codes/javascript/chapter_tree/binary_tree.js

@@ -4,16 +4,16 @@
  * Author: IsChristina (christinaxia77@foxmail.com)
  */
 
-const Tree = require("../include/TreeNode");
-const { printTree } = require("../include/PrintUtil");
+const { TreeNode } = require("../modules/TreeNode");
+const { printTree } = require("../modules/PrintUtil");
 
 /* 初始化二叉树 */
 // 初始化结点
-let n1 = new Tree.TreeNode(1),
-    n2 = new Tree.TreeNode(2),
-    n3 = new Tree.TreeNode(3),
-    n4 = new Tree.TreeNode(4),
-    n5 = new Tree.TreeNode(5);
+let n1 = new TreeNode(1),
+    n2 = new TreeNode(2),
+    n3 = new TreeNode(3),
+    n4 = new TreeNode(4),
+    n5 = new TreeNode(5);
 // 构建引用指向（即指针）
 n1.left = n2;
 n1.right = n3;
@@ -23,7 +23,7 @@ console.log("\n初始化二叉树\n");
 printTree(n1);
 
 /* 插入与删除结点 */
-let P = new Tree.TreeNode(0);
+const P = new TreeNode(0);
 // 在 n1 -> n2 中间插入结点 P
 n1.left = P;
 P.left = n2;

codes/javascript/chapter_tree/binary_tree_bfs.js

@@ -1,18 +1,18 @@
 /**
- * File: binary_tree.js
+ * File: binary_tree_bfs.js
  * Created Time: 2022-12-04
  * Author: IsChristina (christinaxia77@foxmail.com)
  */
 
-const { arrToTree } = require("../include/TreeNode");
-const { printTree } = require("../include/PrintUtil");
+const { arrToTree } = require("../modules/TreeNode");
+const { printTree } = require("../modules/PrintUtil");
 
 /* 层序遍历 */
 function levelOrder(root) {
     // 初始化队列，加入根结点
-    let queue = [root];
+    const queue = [root];
     // 初始化一个列表，用于保存遍历序列
-    let list = [];
+    const list = [];
     while (queue.length) {
         let node = queue.shift();   // 队列出队
         list.push(node.val);        // 保存结点值
@@ -28,10 +28,10 @@ function levelOrder(root) {
 /* Driver Code */
 /* 初始化二叉树 */
 // 这里借助了一个从数组直接生成二叉树的函数
-var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
+const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
 console.log("\n初始化二叉树\n");
 printTree(root);
 
 /* 层序遍历 */
-let list = levelOrder(root);
+const list = levelOrder(root);
 console.log("\n层序遍历的结点打印序列 = " + list);

codes/javascript/chapter_tree/binary_tree_dfs.js

@@ -1,14 +1,14 @@
 /**
- * File: binary_tree.js
+ * File: binary_tree_dfs.js
  * Created Time: 2022-12-04
  * Author: IsChristina (christinaxia77@foxmail.com)
  */
 
-const { arrToTree } = require("../include/TreeNode");
-const { printTree } = require("../include/PrintUtil");
+const { arrToTree } = require("../modules/TreeNode");
+const { printTree } = require("../modules/PrintUtil");
 
 // 初始化列表，用于存储遍历序列
-var list = [];
+const list = [];
 
 /* 前序遍历 */
 function preOrder(root) {
@@ -40,7 +40,7 @@ function postOrder(root) {
 /* Driver Code */
 /* 初始化二叉树 */
 // 这里借助了一个从数组直接生成二叉树的函数
-var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
+const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
 console.log("\n初始化二叉树\n");
 printTree(root);
 

codes/javascript/modules/PrintUtil.js

@@ -98,5 +98,5 @@ function printHeap(arr) {
 module.exports = {
     printLinkedList,
     printTree,
-    printHeap,
+    printHeap
 };

codes/javascript/modules/TreeNode.js

@@ -50,5 +50,5 @@ function arrToTree(arr) {
 
 module.exports = {
     TreeNode,
-    arrToTree,
+    arrToTree
 };

codes/javascript/modules/Vertex.js

@@ -1,5 +1,5 @@
 /**
- * File: Vertex.ts
+ * File: Vertex.js
  * Created Time: 2023-02-15
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */

codes/typescript/chapter_array_and_linkedlist/array.ts

@@ -70,13 +70,13 @@ function find(nums: number[], target: number): number {
 
 /* Driver Code */
 /* 初始化数组 */
-let arr: number[] = new Array(5).fill(0);
+const arr: number[] = new Array(5).fill(0);
 console.log('数组 arr =', arr);
 let nums: number[] = [1, 3, 2, 5, 4];
 console.log('数组 nums =', nums);
 
 /* 随机访问 */
-const random_num = randomAccess(nums);
+let random_num = randomAccess(nums);
 console.log('在 nums 中获取随机元素', random_num);
 
 /* 长度扩展 */
@@ -95,7 +95,7 @@ console.log('删除索引 2 处的元素，得到 nums =', nums);
 traverse(nums);
 
 /* 查找元素 */
-var index: number = find(nums, 3);
+let index = find(nums, 3);
 console.log('在 nums 中查找元素 3 ，得到索引 =', index);
 
 export {};

codes/typescript/chapter_array_and_linkedlist/linked_list.ts

@@ -4,8 +4,8 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { ListNode } from '../module/ListNode';
-import { printLinkedList } from '../module/PrintUtil';
+import { ListNode } from '../modules/ListNode';
+import { printLinkedList } from '../modules/PrintUtil';
 
 /* 在链表的结点 n0 之后插入结点 P */
 function insert(n0: ListNode, P: ListNode): void {

codes/typescript/chapter_array_and_linkedlist/my_list.ts

@@ -97,7 +97,7 @@ class MyList {
     public toArray(): number[] {
         let size = this.size();
         // 仅转换有效长度范围内的列表元素
-        let nums = new Array(size);
+        const nums = new Array(size);
         for (let i = 0; i < size; i++) {
             nums[i] = this.get(i);
         }
@@ -107,7 +107,7 @@ class MyList {
 
 /* Driver Code */
 /* 初始化列表 */
-let list = new MyList();
+const list = new MyList();
 /* 尾部添加元素 */
 list.add(1);
 list.add(3);
@@ -127,7 +127,7 @@ list.remove(3);
 console.log(`删除索引 3 处的元素，得到 list = ${list.toArray()}`);
 
 /* 访问元素 */
-let num = list.get(1);
+const num = list.get(1);
 console.log(`访问索引 1 处的元素，得到 num = ${num}`);
 
 /* 更新元素 */

codes/typescript/chapter_computational_complexity/space_complexity.ts

@@ -4,9 +4,9 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { ListNode } from '../module/ListNode';
-import { TreeNode } from '../module/TreeNode';
-import { printTree } from '../module/PrintUtil';
+import { ListNode } from '../modules/ListNode';
+import { TreeNode } from '../modules/TreeNode';
+import { printTree } from '../modules/PrintUtil';
 
 /* 函数 */
 function constFunc(): number {
@@ -57,7 +57,9 @@ function linearRecur(n: number): void {
 /* 平方阶 */
 function quadratic(n: number): void {
     // 矩阵占用 O(n^2) 空间
-    const numMatrix = Array(n).fill(null).map(() => Array(n).fill(null));
+    const numMatrix = Array(n)
+        .fill(null)
+        .map(() => Array(n).fill(null));
     // 二维列表占用 O(n^2) 空间
     const numList = [];
     for (let i = 0; i < n; i++) {

codes/typescript/chapter_graph/graph_adjacency_list.ts

@@ -4,7 +4,7 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { Vertex } from "../module/Vertex";
+import { Vertex } from '../modules/Vertex';
 
 /* 基于邻接表实现的无向图类 */
 class GraphAdjList {
@@ -30,7 +30,7 @@ class GraphAdjList {
     /* 添加边 */
     addEdge(vet1: Vertex, vet2: Vertex): void {
         if (!this.adjList.has(vet1) || !this.adjList.has(vet2) || vet1 === vet2) {
-            throw new Error("Illegal Argument Exception");
+            throw new Error('Illegal Argument Exception');
         }
         // 添加边 vet1 - vet2
         this.adjList.get(vet1).push(vet2);
@@ -40,7 +40,7 @@ class GraphAdjList {
     /* 删除边 */
     removeEdge(vet1: Vertex, vet2: Vertex): void {
         if (!this.adjList.has(vet1) || !this.adjList.has(vet2) || vet1 === vet2) {
-            throw new Error("Illegal Argument Exception");
+            throw new Error('Illegal Argument Exception');
         }
         // 删除边 vet1 - vet2
         this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);
@@ -57,7 +57,7 @@ class GraphAdjList {
     /* 删除顶点 */
     removeVertex(vet: Vertex): void {
         if (!this.adjList.has(vet)) {
-            throw new Error("Illegal Argument Exception");
+            throw new Error('Illegal Argument Exception');
         }
         // 在邻接表中删除顶点 vet 对应的链表
         this.adjList.delete(vet);
@@ -72,13 +72,13 @@ class GraphAdjList {
 
     /* 打印邻接表 */
     print(): void {
-        console.log("邻接表 =");
+        console.log('邻接表 =');
         for (const [key, value] of this.adjList.entries()) {
             const tmp = [];
             for (const vertex of value) {
                 tmp.push(vertex.val);
             }
-            console.log(key.val + ": " + tmp.join());
+            console.log(key.val + ': ' + tmp.join());
         }
     }
 }
@@ -92,33 +92,40 @@ if (require.main === module) {
         v2 = new Vertex(2),
         v3 = new Vertex(5),
         v4 = new Vertex(4);
-    const edges = [[v0, v1], [v1, v2], [v2, v3], [v0, v3], [v2, v4], [v3, v4]];
+    const edges = [
+        [v0, v1],
+        [v1, v2],
+        [v2, v3],
+        [v0, v3],
+        [v2, v4],
+        [v3, v4]
+    ];
     const graph = new GraphAdjList(edges);
-    console.log("\n初始化后，图为");
+    console.log('\n初始化后，图为');
     graph.print();
 
     /* 添加边 */
     // 顶点 1, 2 即 v0, v2
     graph.addEdge(v0, v2);
-    console.log("\n添加边 1-2 后，图为");
+    console.log('\n添加边 1-2 后，图为');
     graph.print();
 
     /* 删除边 */
     // 顶点 1, 3 即 v0, v1
     graph.removeEdge(v0, v1);
-    console.log("\n删除边 1-3 后，图为");
+    console.log('\n删除边 1-3 后，图为');
     graph.print();
 
     /* 添加顶点 */
     const v5 = new Vertex(6);
     graph.addVertex(v5);
-    console.log("\n添加顶点 6 后，图为");
+    console.log('\n添加顶点 6 后，图为');
     graph.print();
 
     /* 删除顶点 */
     // 顶点 3 即 v1
     graph.removeVertex(v1);
-    console.log("\n删除顶点 3 后，图为");
+    console.log('\n删除顶点 3 后，图为');
     graph.print();
 }
 

codes/typescript/chapter_graph/graph_adjacency_matrix.ts

@@ -92,7 +92,7 @@ class GraphAdjMat {
     }
 }
 
-
+/* Driver Code */
 /* 初始化无向图 */
 // 请注意，edges 元素代表顶点索引，即对应 vertices 元素索引
 const vertices: number[] = [1, 3, 2, 5, 4];

codes/typescript/chapter_graph/graph_bfs.ts

@@ -4,9 +4,8 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
-
-import { GraphAdjList } from './graph_adjacency_list'
-import { Vertex } from '../module/Vertex';
+import { GraphAdjList } from './graph_adjacency_list';
+import { Vertex } from '../modules/Vertex';
 
 /* 广度优先遍历 BFS */
 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
@@ -20,33 +19,43 @@ function graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
     const que = [startVet];
     // 以顶点 vet 为起点，循环直至访问完所有顶点
     while (que.length) {
-        const vet = que.shift();    // 队首顶点出队
-        res.push(vet);                      // 记录访问顶点
+        const vet = que.shift(); // 队首顶点出队
+        res.push(vet); // 记录访问顶点
         // 遍历该顶点的所有邻接顶点
         for (const adjVet of graph.adjList.get(vet) ?? []) {
             if (visited.has(adjVet)) {
-                continue;           // 跳过已被访问过的顶点
+                continue; // 跳过已被访问过的顶点
             }
-            que.push(adjVet);       // 只入队未访问
-            visited.add(adjVet);    // 标记该顶点已被访问
+            que.push(adjVet); // 只入队未访问
+            visited.add(adjVet); // 标记该顶点已被访问
         }
     }
     // 返回顶点遍历序列
     return res;
 }
 
-
 /* Driver Code */
 /* 初始化无向图 */
 const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-const edges = [[v[0], v[1]], [v[0], v[3]], [v[1], v[2]], [v[1], v[4]],
-               [v[2], v[5]], [v[3], v[4]], [v[3], v[6]], [v[4], v[5]],
-               [v[4], v[7]], [v[5], v[8]], [v[6], v[7]], [v[7], v[8]]];
+const edges = [
+    [v[0], v[1]],
+    [v[0], v[3]],
+    [v[1], v[2]],
+    [v[1], v[4]],
+    [v[2], v[5]],
+    [v[3], v[4]],
+    [v[3], v[6]],
+    [v[4], v[5]],
+    [v[4], v[7]],
+    [v[5], v[8]],
+    [v[6], v[7]],
+    [v[7], v[8]]
+];
 const graph = new GraphAdjList(edges);
-console.log("\n初始化后，图为");
+console.log('\n初始化后，图为');
 graph.print();
 
 /* 广度优先遍历 BFS */
 const res = graphBFS(graph, v[0]);
-console.log("\n广度优先遍历（BFS）顶点序列为");
+console.log('\n广度优先遍历（BFS）顶点序列为');
 console.log(Vertex.vetsToVals(res));

codes/typescript/chapter_graph/graph_dfs.ts

@@ -4,14 +4,13 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
-
-import { Vertex } from '../module/Vertex';
+import { Vertex } from '../modules/Vertex';
 import { GraphAdjList } from './graph_adjacency_list';
 
 /* 深度优先遍历 DFS 辅助函数 */
 function dfs(graph: GraphAdjList, visited: Set<Vertex>, res: Vertex[], vet: Vertex): void {
-    res.push(vet);      // 记录访问顶点
-    visited.add(vet);   // 标记该顶点已被访问
+    res.push(vet); // 记录访问顶点
+    visited.add(vet); // 标记该顶点已被访问
     // 遍历该顶点的所有邻接顶点
     for (const adjVet of graph.adjList.get(vet)) {
         if (visited.has(adjVet)) {
@@ -33,17 +32,22 @@ function graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
     return res;
 }
 
-
 /* Driver Code */
 /* 初始化无向图 */
 const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6]);
-const edges = [[v[0], v[1]], [v[0], v[3]], [v[1], v[2]],
-               [v[2], v[5]], [v[4], v[5]], [v[5], v[6]]];
+const edges = [
+    [v[0], v[1]],
+    [v[0], v[3]],
+    [v[1], v[2]],
+    [v[2], v[5]],
+    [v[4], v[5]],
+    [v[5], v[6]]
+];
 const graph = new GraphAdjList(edges);
-console.log("\n初始化后，图为");
+console.log('\n初始化后，图为');
 graph.print();
 
 /* 深度优先遍历 DFS */
 const res = graphDFS(graph, v[0]);
-console.log("\n深度优先遍历（DFS）顶点序列为");
+console.log('\n深度优先遍历（DFS）顶点序列为');
 console.log(Vertex.vetsToVals(res));

codes/typescript/chapter_heap/my_heap.ts

@@ -3,8 +3,8 @@
  * Created Time: 2023-02-07
  * Author: Justin (xiefahit@gmail.com)
  */
- 
-import { printHeap } from "../module/PrintUtil";
+
+import { printHeap } from '../modules/PrintUtil';
 
 /* 最大堆类 */
 class MaxHeap {
@@ -83,7 +83,7 @@ class MaxHeap {
     /* 元素出堆 */
     public poll(): number {
         // 判空处理
-        if (this.isEmpty()) throw new RangeError("Heap is empty.");
+        if (this.isEmpty()) throw new RangeError('Heap is empty.');
         // 交换根结点与最右叶结点（即交换首元素与尾元素）
         this.swap(0, this.size() - 1);
         // 删除结点
@@ -98,7 +98,8 @@ class MaxHeap {
     private siftDown(i: number): void {
         while (true) {
             // 判断结点 i, l, r 中值最大的结点，记为 ma
-            const l = this.left(i), r = this.right(i);
+            const l = this.left(i),
+                r = this.right(i);
             let ma = i;
             if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;
             if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;
@@ -117,7 +118,6 @@ class MaxHeap {
     }
 }
 
-
 function testPush(maxHeap: MaxHeap, val: number): void {
     maxHeap.push(val); // 元素入堆
     console.log(`\n添加元素 ${val} 后`);
@@ -133,7 +133,7 @@ function testPoll(maxHeap: MaxHeap): void {
 /* Driver Code */
 /* 初始化大顶堆 */
 const maxHeap = new MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
-console.log("\n输入列表并建堆后");
+console.log('\n输入列表并建堆后');
 maxHeap.print();
 
 /* 获取堆顶元素 */

codes/typescript/chapter_searching/binary_search.ts

@@ -10,7 +10,7 @@ function binarySearch(nums: number[], target: number): number {
     let i = 0, j = nums.length - 1;
     // 循环，当搜索区间为空时跳出（当 i > j 时为空）
     while (i <= j) {
-        const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        const m = Math.floor((i + j) / 2); // 计算中点索引 m
         if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1;
         } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
@@ -28,7 +28,7 @@ function binarySearch1(nums: number[], target: number): number {
     let i = 0, j = nums.length;
     // 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while (i < j) {
-        const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        const m = Math.floor((i + j) / 2); // 计算中点索引 m
         if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j) 中
             i = m + 1;
         } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m) 中

codes/typescript/chapter_searching/hashing_search.ts

@@ -4,25 +4,22 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
-import { printLinkedList } from "../module/PrintUtil";
-import { ListNode, arrToLinkedList } from "../module/ListNode";
-
+import { ListNode, arrToLinkedList } from '../modules/ListNode';
 
 /* 哈希查找（数组） */
 function hashingSearchArray(map: Map<number, number>, target: number): number {
     // 哈希表的 key: 目标元素，value: 索引
     // 若哈希表中无此 key ，返回 -1
-    return map.has(target) ? map.get(target) as number : -1;
+    return map.has(target) ? (map.get(target) as number) : -1;
 }
 
 /* 哈希查找（链表） */
 function hashingSearchLinkedList(map: Map<number, ListNode>, target: number): ListNode | null {
     // 哈希表的 key: 目标结点值，value: 结点对象
     // 若哈希表中无此 key ，返回 null
-    return map.has(target) ? map.get(target) as ListNode : null;
+    return map.has(target) ? (map.get(target) as ListNode) : null;
 }
 
-
 /* Driver Code */
 const target = 3;
 
@@ -31,20 +28,20 @@ const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
 // 初始化哈希表
 const map = new Map();
 for (let i = 0; i < nums.length; i++) {
-  map.set(nums[i], i);  // key: 元素，value: 索引
+    map.set(nums[i], i); // key: 元素，value: 索引
 }
 const index = hashingSearchArray(map, target);
-console.log("目标元素 3 的索引 = " + index);
+console.log('目标元素 3 的索引 = ' + index);
 
 /* 哈希查找（链表） */
-let head = arrToLinkedList(nums)
+let head = arrToLinkedList(nums);
 // 初始化哈希表
 const map1 = new Map();
 while (head != null) {
-  map1.set(head.val, head);  // key: 结点值，value: 结点
-  head = head.next;
+    map1.set(head.val, head); // key: 结点值，value: 结点
+    head = head.next;
 }
 const node = hashingSearchLinkedList(map1, target);
-console.log("目标结点值 3 的对应结点对象为", node);
+console.log('目标结点值 3 的对应结点对象为', node);
 
 export {};

codes/typescript/chapter_searching/linear_search.ts

@@ -4,7 +4,7 @@
  * Author: Daniel (better.sunjian@gmail.com)
  */
 
-import { ListNode, arrToLinkedList } from '../module/ListNode';
+import { ListNode, arrToLinkedList } from '../modules/ListNode';
 
 /* 线性查找（数组）*/
 function linearSearchArray(nums: number[], target: number): number {

codes/typescript/chapter_sorting/bubble_sort.ts

@@ -1,5 +1,5 @@
 /**
- * File: quick_sort.ts
+ * File: bubble_sort.ts
  * Created Time: 2022-12-12
  * Author: Justin (xiefahit@gmail.com)
  */

codes/typescript/chapter_sorting/insertion_sort.ts

@@ -1,5 +1,5 @@
 /**
- * File: quick_sort.ts
+ * File: insertion_sort.ts
  * Created Time: 2022-12-12
  * Author: Justin (xiefahit@gmail.com)
  */

codes/typescript/chapter_sorting/merge_sort.ts

@@ -1,5 +1,5 @@
 /**
- * File: quick_sort.ts
+ * File: merge_sort.ts
  * Created Time: 2022-12-12
  * Author: Justin (xiefahit@gmail.com)
  */

codes/typescript/chapter_stack_and_queue/array_queue.ts

@@ -71,6 +71,7 @@ class ArrayQueue {
     }
 }
 
+/* Driver Code */
 /* 初始化队列 */
 const capacity = 10;
 const queue = new ArrayQueue(capacity);

codes/typescript/chapter_stack_and_queue/array_stack.ts

@@ -49,7 +49,6 @@ class ArrayStack {
 
 
 /* Driver Code */
-
 /* 初始化栈 */
 const stack = new ArrayStack();
 

codes/typescript/chapter_stack_and_queue/deque.ts

@@ -4,6 +4,7 @@
  * Author: Zhuo Qinyue (1403450829@qq.com)
  */
 
+/* Driver Code */
 /* 初始化双向队列 */
 // TypeScript 没有内置的双端队列，只能把 Array 当作双端队列来使用
 const deque: number[] = [];

codes/typescript/chapter_stack_and_queue/linkedlist_deque.ts

@@ -19,21 +19,21 @@ class ListNode {
 
 /* 基于双向链表实现的双向队列 */
 class LinkedListDeque {
-    front: ListNode;    // 头结点 front
-    rear: ListNode;     // 尾结点 rear
-    len: number;        // 双向队列的长度
+    private front: ListNode;    // 头结点 front
+    private rear: ListNode;     // 尾结点 rear
+    private queSize: number;        // 双向队列的长度
 
     constructor() {
         this.front = null;
         this.rear = null;
-        this.len = 0;
+        this.queSize = 0;
     }
     
     /* 队尾入队操作 */
     pushLast(val: number): void {
         const node: ListNode = new ListNode(val);
         // 若链表为空，则令 front, rear 都指向 node
-        if (this.len === 0) {
+        if (this.queSize === 0) {
             this.front = node;
             this.rear = node;
         } else {
@@ -42,14 +42,14 @@ class LinkedListDeque {
             node.prev = this.rear;
             this.rear = node; // 更新尾结点
         }
-        this.len++;
+        this.queSize++;
     }
 
     /* 队首入队操作 */
     pushFirst(val: number): void {
         const node: ListNode = new ListNode(val);
         // 若链表为空，则令 front, rear 都指向 node
-        if (this.len === 0) {
+        if (this.queSize === 0) {
             this.front = node;
             this.rear = node;
         } else {
@@ -58,12 +58,12 @@ class LinkedListDeque {
             node.next = this.front;
             this.front = node; // 更新头结点
         }
-        this.len++;
+        this.queSize++;
     }
 
     /* 队尾出队操作 */
     pollLast(): number {
-        if (this.len === 0) {
+        if (this.queSize === 0) {
             return null;
         }
         const value: number = this.rear.val; // 存储尾结点值
@@ -74,13 +74,13 @@ class LinkedListDeque {
             this.rear.prev = null;
         }
         this.rear = temp;   // 更新尾结点
-        this.len--;
+        this.queSize--;
         return value;
     }
 
     /* 队首出队操作 */
     pollFirst(): number {
-        if (this.len === 0) {
+        if (this.queSize === 0) {
             return null;
         }
         const value: number = this.front.val; // 存储尾结点值
@@ -91,28 +91,28 @@ class LinkedListDeque {
             this.front.next = null;
         }
         this.front = temp;   // 更新头结点
-        this.len--;
+        this.queSize--;
         return value;
     }
 
     /* 访问队尾元素 */
     peekLast(): number {
-        return this.len === 0 ? null : this.rear.val;
+        return this.queSize === 0 ? null : this.rear.val;
     }
 
     /* 访问队首元素 */
     peekFirst(): number {
-        return this.len === 0 ? null : this.front.val;
+        return this.queSize === 0 ? null : this.front.val;
     }
 
     /* 获取双向队列的长度 */
     size(): number {
-        return this.len;
+        return this.queSize;
     }
 
     /* 判断双向队列是否为空 */
     isEmpty(): boolean {
-        return this.len === 0;
+        return this.queSize === 0;
     }
 
     /* 打印双向队列 */
@@ -127,6 +127,7 @@ class LinkedListDeque {
     }
 }
 
+/* Driver Code */
 /* 初始化双向队列 */
 const linkedListDeque: LinkedListDeque = new LinkedListDeque();
 linkedListDeque.pushLast(3);

codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts

@@ -4,12 +4,12 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-import { ListNode } from "../module/ListNode"
+import { ListNode } from '../modules/ListNode';
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {
     private front: ListNode | null; // 头结点 front
-    private rear: ListNode | null;  // 尾结点 rear
+    private rear: ListNode | null; // 尾结点 rear
     private queSize: number = 0;
 
     constructor() {
@@ -46,8 +46,7 @@ class LinkedListQueue {
     /* 出队 */
     poll(): number {
         const num = this.peek();
-        if (!this.front)
-            throw new Error("队列为空")
+        if (!this.front) throw new Error('队列为空');
         // 删除头结点
         this.front = this.front.next;
         this.queSize--;
@@ -56,8 +55,7 @@ class LinkedListQueue {
 
     /* 访问队首元素 */
     peek(): number {
-        if (this.size === 0)
-            throw new Error("队列为空");
+        if (this.size === 0) throw new Error('队列为空');
         return this.front!.val;
     }
 
@@ -73,7 +71,7 @@ class LinkedListQueue {
     }
 }
 
-
+/* Driver Code */
 /* 初始化队列 */
 const queue = new LinkedListQueue();
 
@@ -83,22 +81,22 @@ 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 poll = queue.poll();
-console.log("出队元素 poll = " + poll + "，出队后 queue = " + queue.toArray());
+console.log('出队元素 poll = ' + poll + '，出队后 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);
 
 export {};

codes/typescript/chapter_stack_and_queue/linkedlist_stack.ts

@@ -4,12 +4,12 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
-import { ListNode } from "../module/ListNode"
+import { ListNode } from '../modules/ListNode';
 
 /* 基于链表实现的栈 */
 class LinkedListStack {
-    private stackPeek: ListNode | null;  // 将头结点作为栈顶
-    private stkSize: number = 0;         // 栈的长度
+    private stackPeek: ListNode | null; // 将头结点作为栈顶
+    private stkSize: number = 0; // 栈的长度
 
     constructor() {
         this.stackPeek = null;
@@ -36,8 +36,7 @@ class LinkedListStack {
     /* 出栈 */
     pop(): number {
         const num = this.peek();
-        if (!this.stackPeek)
-            throw new Error("栈为空");
+        if (!this.stackPeek) throw new Error('栈为空');
         this.stackPeek = this.stackPeek.next;
         this.stkSize--;
         return num;
@@ -45,8 +44,7 @@ class LinkedListStack {
 
     /* 访问栈顶元素 */
     peek(): number {
-        if (!this.stackPeek)
-            throw new Error("栈为空");
+        if (!this.stackPeek) throw new Error('栈为空');
         return this.stackPeek.val;
     }
 
@@ -62,7 +60,7 @@ class LinkedListStack {
     }
 }
 
-
+/* Driver Code */
 /* 初始化栈 */
 const stack = new LinkedListStack();
 
@@ -72,22 +70,22 @@ 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);
 
 export {};

codes/typescript/chapter_stack_and_queue/queue.ts

@@ -4,6 +4,7 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
+/* Driver Code */
 /* 初始化队列 */
 // TypeScript 没有内置的队列，可以把 Array 当作队列来使用 
 const queue: number[] = [];
@@ -14,18 +15,23 @@ queue.push(3);
 queue.push(2);
 queue.push(5);
 queue.push(4);
+console.log("队列 queue =", queue);
 
 /* 访问队首元素 */
 const peek = queue[0];
+console.log("队首元素 peek =", peek);
 
 /* 元素出队 */
 // 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
 const poll = queue.shift();
+console.log("出队元素 poll =", poll, "，出队后 queue = ", queue);
 
 /* 获取队列的长度 */
 const size = queue.length;
+console.log("队列长度 size =", size);
 
 /* 判断队列是否为空 */
-const empty = queue.length === 0;
+const isEmpty = queue.length === 0;
+console.log("队列是否为空 = ", isEmpty);
 
 export {};

codes/typescript/chapter_stack_and_queue/stack.ts

@@ -4,6 +4,7 @@
  * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
  */
 
+/* Driver Code */
 /* 初始化栈 */
 // Typescript 没有内置的栈类，可以把 Array 当作栈来使用 
 const stack: number[] = [];
@@ -14,17 +15,23 @@ stack.push(3);
 stack.push(2);
 stack.push(5);
 stack.push(4);
+console.log("栈 stack =", stack);
 
 /* 访问栈顶元素 */
 const peek = stack[stack.length - 1];
+console.log("栈顶元素 peek =", peek);
 
 /* 元素出栈 */
 const pop = stack.pop();
+console.log("出栈元素 pop =", pop);
+console.log("出栈后 stack =", stack);
 
 /* 获取栈的长度 */
 const size = stack.length;
+console.log("栈的长度 size =", size);
 
 /* 判断是否为空 */
-const is_empty = stack.length === 0;
+const isEmpty = stack.length === 0;
+console.log("栈是否为空 =", isEmpty);
 
 export {};

codes/typescript/chapter_tree/avl_tree.ts

@@ -4,8 +4,8 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { TreeNode } from "../module/TreeNode";
-import { printTree } from "../module/PrintUtil";
+import { TreeNode } from '../modules/TreeNode';
+import { printTree } from '../modules/PrintUtil';
 
 /* AVL 树*/
 class AVLTree {
@@ -22,7 +22,7 @@ class AVLTree {
     }
 
     /* 更新结点高度 */
-    updateHeight(node: TreeNode): void {
+    private updateHeight(node: TreeNode): void {
         // 结点高度等于最高子树高度 + 1
         node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
     }
@@ -36,7 +36,7 @@ class AVLTree {
     }
 
     /* 右旋操作 */
-    rightRotate(node: TreeNode): TreeNode {
+    private rightRotate(node: TreeNode): TreeNode {
         const child = node.left;
         const grandChild = child.right;
         // 以 child 为原点，将 node 向右旋转
@@ -50,7 +50,7 @@ class AVLTree {
     }
 
     /* 左旋操作 */
-    leftRotate(node: TreeNode): TreeNode {
+    private leftRotate(node: TreeNode): TreeNode {
         const child = node.right;
         const grandChild = child.left;
         // 以 child 为原点，将 node 向左旋转
@@ -64,7 +64,7 @@ class AVLTree {
     }
 
     /* 执行旋转操作，使该子树重新恢复平衡 */
-    rotate(node: TreeNode): TreeNode {
+    private rotate(node: TreeNode): TreeNode {
         // 获取结点 node 的平衡因子
         const balanceFactor = this.balanceFactor(node);
         // 左偏树
@@ -100,7 +100,7 @@ class AVLTree {
     }
 
     /* 递归插入结点（辅助方法） */
-    insertHelper(node: TreeNode, val: number): TreeNode {
+    private insertHelper(node: TreeNode, val: number): TreeNode {
         if (node === null) return new TreeNode(val);
         /* 1. 查找插入位置，并插入结点 */
         if (val < node.val) {
@@ -124,7 +124,7 @@ class AVLTree {
     }
 
     /* 递归删除结点（辅助方法） */
-    removeHelper(node: TreeNode, val: number): TreeNode {
+    private removeHelper(node: TreeNode, val: number): TreeNode {
         if (node === null) return null;
         /* 1. 查找结点，并删除之 */
         if (val < node.val) {
@@ -139,7 +139,7 @@ class AVLTree {
                     return null;
                 } else {
                     // 子结点数量 = 1 ，直接删除 node
-                     node = child;
+                    node = child;
                 }
             } else {
                 // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
@@ -156,7 +156,7 @@ class AVLTree {
     }
 
     /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
-    getInOrderNext(node: TreeNode): TreeNode {
+    private getInOrderNext(node: TreeNode): TreeNode {
         if (node === null) return node;
         // 循环访问左子结点，直到叶结点时为最小结点，跳出
         while (node.left !== null) {
@@ -188,13 +188,13 @@ class AVLTree {
 
 function testInsert(tree: AVLTree, val: number): void {
     tree.insert(val);
-    console.log("\n插入结点 " + val + " 后，AVL 树为");
+    console.log('\n插入结点 ' + val + ' 后，AVL 树为');
     printTree(tree.root);
 }
 
 function testRemove(tree: AVLTree, val: number): void {
     tree.remove(val);
-    console.log("\n删除结点 " + val + " 后，AVL 树为");
+    console.log('\n删除结点 ' + val + ' 后，AVL 树为');
     printTree(tree.root);
 }
 
@@ -225,4 +225,4 @@ testRemove(avlTree, 4); // 删除度为 2 的结点
 
 /* 查询结点 */
 const node = avlTree.search(7);
-console.log("\n查找到的结点对象为", node, "，结点值 = " + node.val);
+console.log('\n查找到的结点对象为', node, '，结点值 = ' + node.val);

codes/typescript/chapter_tree/binary_search_tree.ts

@@ -4,8 +4,8 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { TreeNode } from '../module/TreeNode';
-import { printTree } from '../module/PrintUtil';
+import { TreeNode } from '../modules/TreeNode';
+import { printTree } from '../modules/PrintUtil';
 
 /* 二叉搜索树 */
 let root: TreeNode | null;

codes/typescript/chapter_tree/binary_tree.ts

@@ -4,8 +4,8 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { TreeNode } from '../module/TreeNode';
-import { printTree } from '../module/PrintUtil';
+import { TreeNode } from '../modules/TreeNode';
+import { printTree } from '../modules/PrintUtil';
 
 /* 初始化二叉树 */
 // 初始化结点

codes/typescript/chapter_tree/binary_tree_bfs.ts

@@ -4,9 +4,9 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { type TreeNode } from '../module/TreeNode';
-import { arrToTree } from '../module/TreeNode';
-import { printTree } from '../module/PrintUtil';
+import { type TreeNode } from '../modules/TreeNode';
+import { arrToTree } from '../modules/TreeNode';
+import { printTree } from '../modules/PrintUtil';
 
 /* 层序遍历 */
 function levelOrder(root: TreeNode | null): number[] {
@@ -30,7 +30,7 @@ function levelOrder(root: TreeNode | null): number[] {
 /* Driver Code */
 /* 初始化二叉树 */
 // 这里借助了一个从数组直接生成二叉树的函数
-var root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
+const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
 console.log('\n初始化二叉树\n');
 printTree(root);
 

codes/typescript/chapter_tree/binary_tree_dfs.ts

@@ -4,9 +4,9 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-import { type TreeNode } from '../module/TreeNode';
-import { arrToTree } from '../module/TreeNode';
-import { printTree } from '../module/PrintUtil';
+import { type TreeNode } from '../modules/TreeNode';
+import { arrToTree } from '../modules/TreeNode';
+import { printTree } from '../modules/PrintUtil';
 
 // 初始化列表，用于存储遍历序列
 const list: number[] = [];

codes/typescript/modules/TreeNode.ts

@@ -49,4 +49,7 @@ function arrToTree(arr: (number | null)[]): TreeNode | null {
     return root;
 }
 
-export { TreeNode, arrToTree };
+export {
+    TreeNode,
+    arrToTree
+};

codes/typescript/modules/Vertex.ts

@@ -31,4 +31,6 @@ class Vertex {
     }
 }
 
-export { Vertex };
+export {
+    Vertex
+};