LeetCode257. 二叉树的所有路径

257. 二叉树的所有路径

---

一、题目

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。
叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3,null,5]
输出：[“1->2->5”,“1->3”]
示例 2：
输入：root = [1]
输出：[“1”]

提示：

• 树中节点的数目在范围 [1, 100] 内
• -100 <= Node.val <= 100

二、题解

方法一：深度优先搜索递归

算法思路
题目要求找出二叉树从根节点到叶子节点的所有路径。我们可以使用深度优先搜索（DFS）来遍历二叉树，并在遍历的过程中记录从根节点到当前节点的路径。当遇到叶子节点时，我们将路径添加到结果集中。
具体实现
我们可以定义一个辅助函数findPath来进行深度优先搜索。该函数的参数包括当前节点root、结果集result，以及当前路径path。

1. 如果当前节点root为空，直接返回，不进行任何操作。
2. 如果当前节点是叶子节点（即没有左右子节点），将当前节点的值加入到path中，并将path添加到结果集result中。
3. 如果当前节点有左子节点或右子节点（可能同时有），将当前节点的值加入到path中，并加入"->"来表示路径的连接。
4. 对当前节点的左子节点和右子节点分别进行递归调用findPath函数。
   在主函数binaryTreePaths中，我们调用findPath函数，并将结果集作为返回值返回。

class Solution {
public:
    // 辅助函数，用于进行深度优先搜索遍历
    void findPath(TreeNode *root, vector<string>& result, string path){
        if(root == nullptr) return; // 若当前节点为空，则直接返回
        if(!root->left && !root->right){
            // 若当前节点是叶子节点（没有左右子节点）
            path += to_string(root->val); // 将当前节点的值加入到路径中
            result.push_back(path); // 将完整的路径添加到结果集中
        }else if(root->left || root->right){
            // 若当前节点有左子节点或右子节点（可能同时有）
            path += to_string(root->val); // 将当前节点的值加入到路径中
            path += "->"; // 用"->"连接当前节点和后续节点
        }
        findPath(root->left, result, path); // 递归处理左子节点
        findPath(root->right, result, path); // 递归处理右子节点
    }   

    // 主函数，用于返回所有从根节点到叶子节点的路径
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result; // 用于存储结果集
        findPath(root, result, ""); // 调用辅助函数进行深度优先搜索遍历
        return result; // 返回结果集
    }
};

算法分析

1. 时间复杂度：对于二叉树的每个节点，我们只访问一次，同时每次添加路径到结果集的操作的时间复杂度是O(1)。因此，整个算法的时间复杂度是O(N)，其中N是二叉树的节点数量。
2. 空间复杂度：递归函数调用会占用栈空间，递归的深度最坏情况下是二叉树的高度H。在最坏情况下，二叉树可能是一个斜树，高度为N，此时空间复杂度为O(N)。但在一般情况下，二叉树的高度平衡，空间复杂度接近O(logN)。

方法二：迭代

算法思路：
我们可以使用栈来辅助遍历，并在栈中同时保存当前遍历的节点和从根节点到该节点的路径。
具体实现：

1. 创建一个空的字符串数组 result，用于保存所有的路径。
2. 创建两个栈 TreeSt 和 PathSt，分别用于辅助二叉树的深度优先搜索和记录从根节点到当前节点的路径。
3. 如果给定的 root 为空，则直接返回空的结果数组 result。
4. 将 root 节点压入栈 TreeSt，并将其值转换为字符串后压入栈 PathSt。
5. 进入循环，当栈 TreeSt 不为空时，执行以下操作：

• 弹出栈 TreeSt 的栈顶节点 node，同时弹出栈 PathSt 的栈顶路径 path。
• 如果 node 是叶子节点（即没有左右子节点），将 path 添加到结果数组 result 中。
• 如果 node 有右子节点，将右子节点压入栈 TreeSt，并将当前路径 path + “->” + to_string(node->right->val) 压入栈 PathSt。
• 如果 node 有左子节点，将左子节点压入栈 TreeSt，并将当前路径 path + “->” + to_string(node->left->val) 压入栈 PathSt。

6. 循环结束后，返回结果数组 result。

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result; // 用于保存所有从根节点到叶子节点的路径的结果数组
        stack<TreeNode*> TreeSt; // 辅助深度优先搜索的栈，用于遍历二叉树
        stack<string> PathSt; // 记录从根节点到当前节点的路径的栈

        if (root == nullptr) {
            return result; // 如果根节点为空，直接返回空的结果数组
        }

        TreeSt.push(root); // 将根节点压入栈
        PathSt.push(to_string(root->val)); // 将根节点值转换为字符串并压入栈

        while (!TreeSt.empty()) { // 当栈不为空时，进行深度优先搜索
            TreeNode* node = TreeSt.top(); // 弹出栈顶节点
            TreeSt.pop();

            string path = PathSt.top(); // 弹出栈顶路径
            PathSt.pop();

            if (!node->left && !node->right) { // 如果当前节点是叶子节点，将路径加入结果数组
                result.push_back(path);
            }

            if (node->right) { // 如果当前节点有右子节点，将右子节点和对应路径压入栈
                TreeSt.push(node->right);
                PathSt.push(path + "->" + to_string(node->right->val));
            }

            if (node->left) { // 如果当前节点有左子节点，将左子节点和对应路径压入栈
                TreeSt.push(node->left);
                PathSt.push(path + "->" + to_string(node->left->val));
            }
        }

        return result; // 返回所有从根节点到叶子节点的路径的结果数组
    }
};

算法分析：

1. 时间复杂度：遍历整个二叉树的时间复杂度为O(N)，其中N是二叉树的节点数。在遍历的过程中，对于每个节点，都需要将其值转换为字符串，并将其添加到结果数组中，这些操作的时间复杂度都是O(1)。因此，总体的时间复杂度为O(N)。
2. 空间复杂度：栈 TreeSt 和 PathSt 最坏情况下可能同时保存所有节点，因此它们的空间复杂度为O(N)。结果数组 result 最坏情况下也可能保存所有从根节点到叶子节点的路径，因此空间复杂度为O(N)。综合考虑，总体的空间复杂度为O(N)。