力扣算法二叉树篇：二叉树的所有路径

题解：

递归:前序遍历

会用到回溯
递归三部曲：
1、明确递归函数的参数以及返回值
传入根节点，使用一位数组记录一条路径，使用一位数组存放结果集，将路径字符串化后存入结果集 ,不需要返回值。因此参数为 二叉树的结点、一维数组path，一维数组result
2、确定递归终止条件
当到达叶节点时终止
3、确定单层递归逻辑
前序遍历，先处理中间结点（要记录的路径上的结点），终止逻辑编写，然后递归左右孩子结点，递归前先判空，递归完要回溯，才能加入新路径

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    void getPath(TreeNode* cur,vector<int>& path,vector<string>& result){
        //处理中间结点 加入path
        path.push_back(cur->val);
        //到达叶子结点则终止 此处不对cur判空 下面递归时保证了所传入的结点不为空
        if(cur->left == NULL && cur->right == NULL){
            string spath;
            //将路径加入结果集
            for(int i = 0;i<path.size()-1;i++){
                spath += to_string(path[i]);
                spath += "->";
            }
            //将路径末加上
            spath += to_string(path[path.size()-1]);
            result.push_back(spath);
            return;
        }
        //递归
        //左
        if(cur->left){
            getPath(cur->left,path,result);
            //回溯
            path.pop_back();
        }
        //右
        if(cur->right){
            getPath(cur->right,path,result);
            //回溯
            path.pop_back();
        }
        return;
    }
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        //前序遍历 回溯记录路径 以回退一个路径进入另一个路径
        vector<int> path;
        vector<string> result;
        if(root == NULL){
            return result;
        }
        getPath(root,path,result);
        return result;
    }
};

迭代：前序遍历

模拟递归用一个栈，存放对应的遍历路径用一个栈

class 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;
    }
};