力扣：二叉树的所有路径

力扣：二叉树的所有路径
代码随想录

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

叶子节点 是指没有子节点的节点。

思路：
前中后遍历方法都能够遍历所有可能的路径。
要遍历节点的时候要用一个容器存储路径，当达到可行的时候要，把路径输出，当不可行，要回退、同时还要出容器中的元素。

代码：

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& path, vector<string>& result){
        //if(!cur) return ;
        path.push_back(cur->val);
        if(cur->left == nullptr && cur->right == nullptr) {
            string s;
            for(int i = 0; i < path.size()-1; i++){
                s += to_string(path[i]);
                s += "->";
            }
            s += to_string(path[path.size()-1]);
            result.push_back(s);
            return;
        }
        if(cur->left){
            traversal(cur->left, path, result);
            path.pop_back();
        }
        if(cur->right){
            traversal(cur->right, path, result);
            path.pop_back();
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        
        vector<int> v;
        vector<string>result;
        if(!root) return result;
        traversal(root, v,result);
        return result;
    }
};

精简代码：
解释：
每次 path + "->"都是产生新的字符串，即每一条路都会是一个新字符串，只有遇到了正确的路才会将正确的字符串放入 result 中。每个递归函数中的每个path都是不一样的且都是不会变的因为传入的path是一个新的字符串通过 path += to_string(cur->val);改变了一次之后，之后的递归调用都是产生新的字符串，所以每个递归函数的字符串都是不一样的且都是不会变得，所以失败了回退到当前递归函数，操作的字符串又是当前递归函数的字符串。

代码：

class Solution {
private:

    void traversal(TreeNode* cur, string path, vector<string>& result) {
        path += to_string(cur->val); // 中
        if (cur->left == NULL && cur->right == NULL) {
            result.push_back(path);
            return;
        }
        if (cur->left) traversal(cur->left, path + "->", result); // 左
        if (cur->right) traversal(cur->right, path + "->", result); // 右
    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        string path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;

    }
};

迭代法：
通过前序遍历每一个元素，每一条路径都添加到栈中。
与上相同，每一个path都是一个新字符串（一条路径、pathSt.push(path + “->” + to_string(node->right->val));）（都是从栈中取出，栈中每个元素都代表一条路径string path =
pathSt.top();pathSt.pop(); // 取出该节点对应的路径）

代码：

lass Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        stack<TreeNode*> treeSt;// 保存树的遍历节点
        stack<string> pathSt;   // 保存遍历路径的节点
        vector<string> result;  // 保存最终路径集合
        if (root == NULL) 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 == NULL && node->right == NULL) { // 遇到叶子节点
                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;
    }
};

前中后遍历方法都能够遍历所有可能的路径。
思考各种情况：然后对应写代码。