一文吃透斐波那契变种DP！LeetCode 257「二叉树的所有路径」两大解法多语言题解-CSDN博客

本文链接：https://blog.csdn.net/CCIEHL/article/details/148269531

一、题目简介

LeetCode 257《二叉树的所有路径》（Binary Tree Paths）是典型的树形递归、回溯题。它要求你找出从根节点到每个叶子节点的所有路径，常用于考查递归、深度优先遍历（DFS）与字符串拼接等基础功。

二、题目描述

给定一棵二叉树的根节点 root，返回所有从根到叶子的路径，每条路径用字符串表示，节点值用"->"连接。

三、示例分析

示例1：

输入: root = [1,2,3,null,5]
输出: ["1->2->5","1->3"]

路径1：1->2->5
路径2：1->3

四、解题思路与详细步骤

方案一：递归深度优先遍历（DFS）

步骤详解

用辅助函数dfs递归遍历树，每次传递当前路径字符串。
递归终止：如果当前节点是叶子节点（无左右子树），把完整路径加入答案。
递归分支：递归遍历左右子树，路径字符串拼接上当前节点值和"->"。
返回所有路径组成的字符串列表。

优缺点

写法简洁，递归表达清晰。
递归深度等于树高，适合路径收集题型。

方案二：栈+迭代模拟DFS

步骤详解

用显式栈（list/stack）保存节点和当前路径字符串的pair。
循环出栈节点，如果是叶子节点，把路径加入结果。
如果有右/左子树，把子节点和新路径分别入栈。
直到栈空，全部路径遍历完毕。

优缺点

适合避免递归栈溢出，容易调试。
代码比递归略繁琐，空间略高但同阶。

五、代码实现（Python/Java/C++）

Python实现

解法一：递归DFS

class Solution:
    def binaryTreePaths(self, root):
        def dfs(node, path, res):
            if not node:
                return
            if not node.left and not node.right:
                res.append(path + str(node.val))
            else:
                dfs(node.left, path + str(node.val) + "->", res)
                dfs(node.right, path + str(node.val) + "->", res)
        res = []
        dfs(root, "", res)
        return res

解法二：迭代栈

class Solution:
    def binaryTreePaths(self, root):
        if not root:
            return []
        stack, res = [(root, str(root.val))], []
        while stack:
            node, path = stack.pop()
            if not node.left and not node.right:
                res.append(path)
            if node.right:
                stack.append((node.right, path + "->" + str(node.right.val)))
            if node.left:
                stack.append((node.left, path + "->" + str(node.left.val)))
        return res

Java实现

解法一：递归DFS

import java.util.*;
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        dfs(root, "", res);
        return res;
    }
    void dfs(TreeNode node, String path, List<String> res) {
        if (node == null) return;
        if (node.left == null && node.right == null) {
            res.add(path + node.val);
        } else {
            dfs(node.left, path + node.val + "->", res);
            dfs(node.right, path + node.val + "->", res);
        }
    }
}

解法二：栈迭代

import java.util.*;
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        if (root == null) return res;
        Stack<Pair<TreeNode, String>> stack = new Stack<>();
        stack.push(new Pair<>(root, String.valueOf(root.val)));
        while (!stack.isEmpty()) {
            Pair<TreeNode, String> p = stack.pop();
            TreeNode node = p.getKey();
            String path = p.getValue();
            if (node.left == null && node.right == null) {
                res.add(path);
            }
            if (node.right != null)
                stack.push(new Pair<>(node.right, path + "->" + node.right.val));
            if (node.left != null)
                stack.push(new Pair<>(node.left, path + "->" + node.left.val));
        }
        return res;
    }
    // Pair类可用AbstractMap.SimpleEntry或自定义
}

C++实现

解法一：递归DFS

#include <vector>
#include <string>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int v): val(v), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        dfs(root, "", res);
        return res;
    }
    void dfs(TreeNode* node, string path, vector<string>& res) {
        if (!node) return;
        if (!node->left && !node->right)
            res.push_back(path + to_string(node->val));
        else {
            dfs(node->left, path + to_string(node->val) + "->", res);
            dfs(node->right, path + to_string(node->val) + "->", res);
        }
    }
};

解法二：栈迭代

#include <vector>
#include <string>
#include <stack>
using namespace std;

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        if (!root) return res;
        stack<pair<TreeNode*, string>> stk;
        stk.push({root, to_string(root->val)});
        while (!stk.empty()) {
            auto [node, path] = stk.top(); stk.pop();
            if (!node->left && !node->right)
                res.push_back(path);
            if (node->right)
                stk.push({node->right, path + "->" + to_string(node->right->val)});
            if (node->left)
                stk.push({node->left, path + "->" + to_string(node->left->val)});
        }
        return res;
    }
};