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
2026-04-13 18:00:18 +08:00 · 2023-03-03 01:34:53 +08:00
parent 7b41e6c2f0
commit e4a98bc9c5
61 changed files with 324 additions and 290 deletions
--- a/codes/typescript/chapter_array_and_linkedlist/array.ts
+++ b/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 {};
--- a/codes/typescript/chapter_array_and_linkedlist/linked_list.ts
+++ b/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 {
--- a/codes/typescript/chapter_array_and_linkedlist/my_list.ts
+++ b/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}`);

 /* 更新元素 */
--- a/codes/typescript/chapter_computational_complexity/space_complexity.ts
+++ b/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++) {
--- a/codes/typescript/chapter_graph/graph_adjacency_list.ts
+++ b/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();
 }

--- a/codes/typescript/chapter_graph/graph_adjacency_matrix.ts
+++ b/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];
--- a/codes/typescript/chapter_graph/graph_bfs.ts
+++ b/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));
--- a/codes/typescript/chapter_graph/graph_dfs.ts
+++ b/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));
--- a/codes/typescript/chapter_heap/my_heap.ts
+++ b/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();

 /* 获取堆顶元素 */
--- a/codes/typescript/chapter_searching/binary_search.ts
+++ b/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) 中
--- a/codes/typescript/chapter_searching/hashing_search.ts
+++ b/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 {};
--- a/codes/typescript/chapter_searching/linear_search.ts
+++ b/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 {
--- a/codes/typescript/chapter_sorting/bubble_sort.ts
+++ b/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)
 */
--- a/codes/typescript/chapter_sorting/insertion_sort.ts
+++ b/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)
 */
--- a/codes/typescript/chapter_sorting/merge_sort.ts
+++ b/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)
 */
--- a/codes/typescript/chapter_stack_and_queue/array_queue.ts
+++ b/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);
--- a/codes/typescript/chapter_stack_and_queue/array_stack.ts
+++ b/codes/typescript/chapter_stack_and_queue/array_stack.ts
@@ -49,7 +49,6 @@ class ArrayStack {


 /* Driver Code */
-
 /* 初始化栈 */
 const stack = new ArrayStack();

--- a/codes/typescript/chapter_stack_and_queue/deque.ts
+++ b/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[] = [];
--- a/codes/typescript/chapter_stack_and_queue/linkedlist_deque.ts
+++ b/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);
--- a/codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts
+++ b/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 {};
--- a/codes/typescript/chapter_stack_and_queue/linkedlist_stack.ts
+++ b/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 {};
--- a/codes/typescript/chapter_stack_and_queue/queue.ts
+++ b/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 {};
--- a/codes/typescript/chapter_stack_and_queue/stack.ts
+++ b/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 {};
--- a/codes/typescript/chapter_tree/avl_tree.ts
+++ b/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);
--- a/codes/typescript/chapter_tree/binary_search_tree.ts
+++ b/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;
--- a/codes/typescript/chapter_tree/binary_tree.ts
+++ b/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';

 /* 初始化二叉树 */
 // 初始化结点
--- a/codes/typescript/chapter_tree/binary_tree_bfs.ts
+++ b/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);

--- a/codes/typescript/chapter_tree/binary_tree_dfs.ts
+++ b/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[] = [];
--- a/codes/typescript/modules/ListNode.ts
+++ b/codes/typescript/modules/ListNode.ts
--- a/codes/typescript/modules/PrintUtil.ts
+++ b/codes/typescript/modules/PrintUtil.ts
--- a/codes/typescript/modules/TreeNode.ts
+++ b/codes/typescript/modules/TreeNode.ts
@@ -49,4 +49,7 @@ function arrToTree(arr: (number | null)[]): TreeNode | null {
    return root;
 }

-export { TreeNode, arrToTree };
+export {
+    TreeNode,
+    arrToTree
+};
--- a/codes/typescript/modules/Vertex.ts
+++ b/codes/typescript/modules/Vertex.ts
@@ -31,4 +31,6 @@ class Vertex {
    }
 }

-export { Vertex };
+export {
+    Vertex
+};