JavaScript算法：求二叉树从根到叶的所有路径和

如果你希望求某一特定路径（例如从根到叶子）上数字的和，那么问题就转变为了“求二叉树从根到叶的所有路径和”。

例如，考虑下面的二叉树：

        5
      /   \
     3     8
    / \   / \
   1   4 7   9

5 -> 3 -> 1  为 531
5 -> 3 -> 4  为 534
5 -> 8 -> 7  为 587
5 -> 8 -> 9  为 589

这四个路径的和为：531 + 534 + 587 + 589 = 2241。

为了解决这个问题，你可以使用深度优先搜索 (DFS) 来遍历每一条路径，并在遍历过程中累计路径的和：

class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

function sumPaths(node, currentSum = 0) {
  if (!node) return 0;

  currentSum = currentSum * 10 + node.value;

  // 如果是叶子节点，直接返回当前和
  if (!node.left && !node.right) return currentSum;

  // 否则返回左右子树的和
  return sumPaths(node.left, currentSum) + sumPaths(node.right, currentSum);
}

// 使用上面的树作为示例
const root = new TreeNode(5);
root.left = new TreeNode(3);
root.right = new TreeNode(8);
root.left.left = new TreeNode(1);
root.left.right = new TreeNode(4);
root.right.left = new TreeNode(7);
root.right.right = new TreeNode(9);

console.log(sumPaths(root)); // 输出: 2241

深度优先搜索（Deep First Search，简称 DFS）是一种用于遍历或搜索树或图的算法。在树或图上进行搜索的过程中，DFS 尽可能沿着分支深入到树或图的尽头，然后再回溯至其他分支继续探索，直到已经访问过所有可能的路径。

工作原理：

1. 从起始节点开始。
2. 探索尽可能深的分支。
3. 如果当前节点没有未探索的分支，则回溯。
4. 探索下一个分支。
5. 重复以上步骤，直到访问所有的节点。

实现：

DFS 可以通过递归或使用堆栈实现。

递归实现：

在树的情况下，可以递归地访问每个节点的子节点。

function dfs(node) {
  if (node == null) return;

  console.log(node.value);  // 处理当前节点
  dfs(node.left);  // 递归访问左子节点
  dfs(node.right);  // 递归访问右子节点
}

使用堆栈实现：

堆栈可以帮助保存待访问的节点。一般在图中使用堆栈实现 DFS，因为图可能含有循环，需要一个额外的数据结构来跟踪已访问的节点。

function dfs(graph, start) {
  let stack = [];
  let visited = new Set();

  stack.push(start);

  while (stack.length) {
    let node = stack.pop();
    if (!visited.has(node)) {
      console.log(node);  // 处理当前节点
      visited.add(node);

      // 添加未访问的邻接节点到堆栈
      for (let neighbor of graph[node]) {
        if (!visited.has(neighbor)) {
          stack.push(neighbor);
        }
      }
    }
  }
}

用途：

• 在图中寻找路径。
• 拓扑排序。
• 查找图中的连通分量。
• 解决一些组合问题，如寻找所有可能的解决方案。
• 在某些情况下用于寻找最优解。

注意：

在使用 DFS 时，需要注意避免重复访问已经访问过的节点，尤其是在图中，因为图可能包含循环。为此，可以使用一个集合或其他数据结构来跟踪已访问的节点。