Leetcode Path Sum II

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

return

[
   [5,4,11,2],
   [5,8,4,5]
]
遞迴實現，注意遞迴實現時，放入vector中的資料，之後要pop_back出，此題中path引數沒有使用引用，是按值傳遞的

class Solution {
public:
    vector<vector<int> > res;
    
    void solvePathSum(TreeNode *root, int sum, vector<int> path){
        if(root == NULL) return;
        if(root->left == NULL && root->right == NULL){
            if(sum == root->val){
                path.push_back(root->val);
                res.push_back(path);
            }
            return;
        }
        path.push_back(root->val);
        solvePathSum(root->left,sum-root->val,path);
        solvePathSum(root->right,sum-root->val,path);
    }

    vector<vector<int> > pathSum(TreeNode *root, int sum) {
        vector<int> path;
        solvePathSum(root,sum,path);
        return res;
    }
};

 非遞迴實現，在節點中新增了一個指向父節點的指標

class Solution {
public:
    struct TreeNodeSum{
        TreeNode *node;
        TreeNodeSum *parent;
        int sum;
        TreeNodeSum(TreeNode* node_, int sum_, TreeNodeSum* parent_ = NULL ):node(node_),sum(sum_),parent(parent_){}
    };
    
    vector<vector<int> > pathSum(TreeNode *root, int sum) {
        vector<vector<int> >res;
        if(root == NULL) return res;
        queue<TreeNodeSum *> que;
        que.push(new TreeNodeSum(root,root->val));
        while(!que.empty()){
            TreeNodeSum *tmp = que.front();que.pop();
            TreeNode *node = tmp->node;
            if(!node->left && !node->right && tmp->sum == sum){
                vector<int> path;
                while(tmp){
                    path.push_back(tmp->node->val);
                    tmp = tmp->parent;
                }
                reverse(path.begin(),path.end());
                res.push_back(path);
                continue;
            }
            if(node->left){
                TreeNodeSum *nodeSum = new TreeNodeSum(node->left,node->left->val+tmp->sum,tmp);
                que.push(nodeSum);
            }
            if(node->right ){
                TreeNodeSum *nodeSum = new TreeNodeSum(node->right,node->right->val+tmp->sum,tmp);
                que.push(nodeSum);
            }
        }
        return res;
    }
};