Fix the indentation of JS and TS code.

codes/javascript/chapter_backtracking/preorder_traversal_i_compact.js

@@ -9,25 +9,25 @@ const { printTree } = require('../modules/PrintUtil');
 
 /* 前序遍历：例题一 */
 function preOrder(root, res) {
-  if (root === null) {
-    return;
-  }
-  if (root.val === 7) {
-    // 记录解
-    res.push(root);
-  }
-  preOrder(root.left, res);
-  preOrder(root.right, res);
+    if (root === null) {
+        return;
+    }
+    if (root.val === 7) {
+        // 记录解
+        res.push(root);
+    }
+    preOrder(root.left, res);
+    preOrder(root.right, res);
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 前序遍历
 const res = [];
 preOrder(root, res);
 
-console.log("\n输出所有值为 7 的节点");
-console.log(res.map(node => node.val));
+console.log('\n输出所有值为 7 的节点');
+console.log(res.map((node) => node.val));

codes/javascript/chapter_backtracking/preorder_traversal_ii_compact.js

@@ -9,24 +9,24 @@ const { printTree } = require('../modules/PrintUtil');
 
 /* 前序遍历：例题二 */
 function preOrder(root, path, res) {
-  if (root === null) {
-    return;
-  }
-  // 尝试
-  path.push(root);
-  if (root.val === 7) {
-    // 记录解
-    res.push([...path]);
-  }
-  preOrder(root.left, path, res);
-  preOrder(root.right, path, res);
-  // 回退
-  path.pop();
+    if (root === null) {
+        return;
+    }
+    // 尝试
+    path.push(root);
+    if (root.val === 7) {
+        // 记录解
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // 回退
+    path.pop();
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 前序遍历
@@ -34,7 +34,7 @@ const path = [];
 const res = [];
 preOrder(root, path, res);
 
-console.log("\n输出所有根节点到节点 7 的路径");
-res.forEach(path => {
-  console.log(path.map(node => node.val));
+console.log('\n输出所有根节点到节点 7 的路径');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
 });

codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js

@@ -9,25 +9,25 @@ const { printTree } = require('../modules/PrintUtil');
 
 /* 前序遍历：例题三 */
 function preOrder(root, path, res) {
-  // 剪枝
-  if (root === null || root.val === 3) {
-    return;
-  }
-  // 尝试
-  path.push(root);
-  if (root.val === 7) {
-    // 记录解
-    res.push([...path]);
-  }
-  preOrder(root.left, path, res);
-  preOrder(root.right, path, res);
-  // 回退
-  path.pop();
+    // 剪枝
+    if (root === null || root.val === 3) {
+        return;
+    }
+    // 尝试
+    path.push(root);
+    if (root.val === 7) {
+        // 记录解
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // 回退
+    path.pop();
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 前序遍历
@@ -35,7 +35,7 @@ const path = [];
 const res = [];
 preOrder(root, path, res);
 
-console.log("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
-res.forEach(path => {
-  console.log(path.map(node => node.val));
+console.log('\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
 });

codes/javascript/chapter_backtracking/preorder_traversal_iii_template.js

@@ -9,61 +9,61 @@ const { printTree } = require('../modules/PrintUtil');
 
 /* 判断当前状态是否为解 */
 function isSolution(state) {
-  return state && state[state.length - 1]?.val === 7;
+    return state && state[state.length - 1]?.val === 7;
 }
 
 /* 记录解 */
 function recordSolution(state, res) {
-  res.push([...state]);
+    res.push([...state]);
 }
 
 /* 判断在当前状态下，该选择是否合法 */
 function isValid(state, choice) {
-  return choice !== null && choice.val !== 3;
+    return choice !== null && choice.val !== 3;
 }
 
 /* 更新状态 */
 function makeChoice(state, choice) {
-  state.push(choice);
+    state.push(choice);
 }
 
 /* 恢复状态 */
 function undoChoice(state) {
-  state.pop();
+    state.pop();
 }
 
 /* 回溯算法：例题三 */
 function backtrack(state, choices, res) {
-  // 检查是否为解
-  if (isSolution(state)) {
-    // 记录解
-    recordSolution(state, res);
-    return;
-  }
-  // 遍历所有选择
-  for (const choice of choices) {
-    // 剪枝：检查选择是否合法
-    if (isValid(state, choice)) {
-      // 尝试：做出选择，更新状态
-      makeChoice(state, choice);
-      // 进行下一轮选择
-      backtrack(state, [choice.left, choice.right], res);
-      // 回退：撤销选择，恢复到之前的状态
-      undoChoice(state);
+    // 检查是否为解
+    if (isSolution(state)) {
+        // 记录解
+        recordSolution(state, res);
+        return;
+    }
+    // 遍历所有选择
+    for (const choice of choices) {
+        // 剪枝：检查选择是否合法
+        if (isValid(state, choice)) {
+            // 尝试：做出选择，更新状态
+            makeChoice(state, choice);
+            // 进行下一轮选择
+            backtrack(state, [choice.left, choice.right], res);
+            // 回退：撤销选择，恢复到之前的状态
+            undoChoice(state);
+        }
     }
-  }
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 回溯算法
 const res = [];
 backtrack([], [root], res);
 
-console.log("\n输出所有根节点到节点 7 的路径，要求路径中不包含值为 3 的节点");
-res.forEach(path => {
-  console.log(path.map(node => node.val));
+console.log('\n输出所有根节点到节点 7 的路径，要求路径中不包含值为 3 的节点');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
 });

codes/typescript/chapter_backtracking/preorder_traversal_i_compact.ts

@@ -10,25 +10,27 @@ import { printTree } from '../modules/PrintUtil';
 
 /* 前序遍历：例题一 */
 function preOrder(root: TreeNode | null, res: TreeNode[]): void {
-  if (root === null) {
-    return;
-  }
-  if (root.val === 7) {
-    // 记录解
-    res.push(root);
-  }
-  preOrder(root.left, res);
-  preOrder(root.right, res);
+    if (root === null) {
+        return;
+    }
+    if (root.val === 7) {
+        // 记录解
+        res.push(root);
+    }
+    preOrder(root.left, res);
+    preOrder(root.right, res);
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 前序遍历
 const res: TreeNode[] = [];
 preOrder(root, res);
 
-console.log("\n输出所有值为 7 的节点");
-console.log(res.map(node => node.val));
+console.log('\n输出所有值为 7 的节点');
+console.log(res.map((node) => node.val));
+
+export {};

codes/typescript/chapter_backtracking/preorder_traversal_ii_compact.ts

@@ -9,25 +9,29 @@ import { arrToTree } from '../modules/TreeNode';
 import { printTree } from '../modules/PrintUtil';
 
 /* 前序遍历：例题二 */
-function preOrder(root: TreeNode | null, path: TreeNode[], res: TreeNode[][]): void {
-  if (root === null) {
-    return;
-  }
-  // 尝试
-  path.push(root);
-  if (root.val === 7) {
-    // 记录解
-    res.push([...path]);
-  }
-  preOrder(root.left, path, res);
-  preOrder(root.right, path, res);
-  // 回退
-  path.pop();
+function preOrder(
+    root: TreeNode | null,
+    path: TreeNode[],
+    res: TreeNode[][]
+): void {
+    if (root === null) {
+        return;
+    }
+    // 尝试
+    path.push(root);
+    if (root.val === 7) {
+        // 记录解
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // 回退
+    path.pop();
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 前序遍历
@@ -35,7 +39,9 @@ const path: TreeNode[] = [];
 const res: TreeNode[][] = [];
 preOrder(root, path, res);
 
-console.log("\n输出所有根节点到节点 7 的路径");
-res.forEach(path => {
-  console.log(path.map(node => node.val));
+console.log('\n输出所有根节点到节点 7 的路径');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
 });
+
+export {};

codes/typescript/chapter_backtracking/preorder_traversal_iii_compact.ts

@@ -9,26 +9,30 @@ import { arrToTree } from '../modules/TreeNode';
 import { printTree } from '../modules/PrintUtil';
 
 /* 前序遍历：例题三 */
-function preOrder(root: TreeNode | null, path: TreeNode[], res: TreeNode[][]): void {
-  // 剪枝
-  if (root === null || root.val === 3) {
-    return;
-  }
-  // 尝试
-  path.push(root);
-  if (root.val === 7) {
-    // 记录解
-    res.push([...path]);
-  }
-  preOrder(root.left, path, res);
-  preOrder(root.right, path, res);
-  // 回退
-  path.pop();
+function preOrder(
+    root: TreeNode | null,
+    path: TreeNode[],
+    res: TreeNode[][]
+): void {
+    // 剪枝
+    if (root === null || root.val === 3) {
+        return;
+    }
+    // 尝试
+    path.push(root);
+    if (root.val === 7) {
+        // 记录解
+        res.push([...path]);
+    }
+    preOrder(root.left, path, res);
+    preOrder(root.right, path, res);
+    // 回退
+    path.pop();
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 前序遍历
@@ -36,7 +40,9 @@ const path: TreeNode[] = [];
 const res: TreeNode[][] = [];
 preOrder(root, path, res);
 
-console.log("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
-res.forEach(path => {
-  console.log(path.map(node => node.val));
+console.log('\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
 });
+
+export {};

codes/typescript/chapter_backtracking/preorder_traversal_iii_template.ts

@@ -10,61 +10,67 @@ import { printTree } from '../modules/PrintUtil';
 
 /* 判断当前状态是否为解 */
 function isSolution(state: TreeNode[]): boolean {
-  return state && state[state.length - 1]?.val === 7;
+    return state && state[state.length - 1]?.val === 7;
 }
 
 /* 记录解 */
 function recordSolution(state: TreeNode[], res: TreeNode[][]): void {
-  res.push([...state]);
+    res.push([...state]);
 }
 
 /* 判断在当前状态下，该选择是否合法 */
 function isValid(state: TreeNode[], choice: TreeNode): boolean {
-  return choice !== null && choice.val !== 3;
+    return choice !== null && choice.val !== 3;
 }
 
 /* 更新状态 */
 function makeChoice(state: TreeNode[], choice: TreeNode): void {
-  state.push(choice);
+    state.push(choice);
 }
 
 /* 恢复状态 */
 function undoChoice(state: TreeNode[]): void {
-  state.pop();
+    state.pop();
 }
 
 /* 回溯算法：例题三 */
-function backtrack(state: TreeNode[], choices: TreeNode[], res: TreeNode[][]): void {
-  // 检查是否为解
-  if (isSolution(state)) {
-    // 记录解
-    recordSolution(state, res);
-    return;
-  }
-  // 遍历所有选择
-  for (const choice of choices) {
-    // 剪枝：检查选择是否合法
-    if (isValid(state, choice)) {
-      // 尝试：做出选择，更新状态
-      makeChoice(state, choice);
-      // 进行下一轮选择
-      backtrack(state, [choice.left, choice.right], res);
-      // 回退：撤销选择，恢复到之前的状态
-      undoChoice(state);
+function backtrack(
+    state: TreeNode[],
+    choices: TreeNode[],
+    res: TreeNode[][]
+): void {
+    // 检查是否为解
+    if (isSolution(state)) {
+        // 记录解
+        recordSolution(state, res);
+        return;
+    }
+    // 遍历所有选择
+    for (const choice of choices) {
+        // 剪枝：检查选择是否合法
+        if (isValid(state, choice)) {
+            // 尝试：做出选择，更新状态
+            makeChoice(state, choice);
+            // 进行下一轮选择
+            backtrack(state, [choice.left, choice.right], res);
+            // 回退：撤销选择，恢复到之前的状态
+            undoChoice(state);
+        }
     }
-  }
 }
 
 // Driver Code
 const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
-console.log("\n初始化二叉树");
+console.log('\n初始化二叉树');
 printTree(root);
 
 // 回溯算法
 const res: TreeNode[][] = [];
 backtrack([], [root], res);
 
-console.log("\n输出所有根节点到节点 7 的路径，要求路径中不包含值为 3 的节点");
-res.forEach(path => {
-  console.log(path.map(node => node.val));
+console.log('\n输出所有根节点到节点 7 的路径，要求路径中不包含值为 3 的节点');
+res.forEach((path) => {
+    console.log(path.map((node) => node.val));
 });
+
+export {};