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]
]

解题思路：

在path sum I中我们判断了一棵树中是否存在满足条件的路径，而path Sum II 则是找到所有符合条件的路径。

用递归方法思考的话：假如已知根节点的左子树满足条件的路径pathsleft，已知根节点右子树中满足条件的路径pathsright，那么怎样整合得到整棵树的满足条件的所有路径？答案是只需要在所有子路径的开头加入根节点。

根据上面的思想，我们可以写出下面的代码：

vector<vector<int>> pathSum(TreeNode* root, int sum) {} 这是我们需要实现的功能函数

 <span style="white-space:pre">	</span>vector<vector<int>> pathsleft;
        vector<vector<int>> pathsright;
        if(root->left) pathsleft = pathSum(root->left,sum-root->val);
        if(root->right) pathsright = pathSum(root->right,sum-root->val);
        for(auto p:pathsleft){
            p.insert(p.begin(),root->val);
            paths.push_back(p);
        }
        for(auto p:pathsright){
            p.insert(p.begin(),root->val);
            paths.push_back(p);
        }

那么递归的出口是什么呢？当然能直观的想到，当我们找到一个叶子节点的时候，就可以判断这个路径是否符合要求了？因此递归的出口应该是每次找到叶子节点。当然不能忘记加入根节点为空时的特殊情况，递归出口需要加入判断根节点是否为空的语句，这个语句只可能是第一次调用函数时，判断一棵树是否为空，在之后的重复调用中，它将不在作用。

        if(!root->left && !root->right){
            if(sum==root->val){
                vector<int> t;
                t.push_back(sum);
                paths.push_back(t);
            }
            return paths;
        }

整个程序如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> paths;
        if(!root) return paths;
        if(!root->left && !root->right){
            if(sum==root->val){
                vector<int> t;
                t.push_back(sum);
                paths.push_back(t);
            }
            return paths;
        }
        vector<vector<int>> pathsleft;
        vector<vector<int>> pathsright;
        if(root->left) pathsleft = pathSum(root->left,sum-root->val);
        if(root->right) pathsright = pathSum(root->right,sum-root->val);
        for(auto p:pathsleft){
            p.insert(p.begin(),root->val);
            paths.push_back(p);
        }
        for(auto p:pathsright){
            p.insert(p.begin(),root->val);
            paths.push_back(p);
        }
        return paths;
    }
};

分析：这个程序中每次调用 都会新建3个

<span style="font-family:Times New Roman;">  vector<vector<int>> paths;
 vector<vector<int>> pathsleft;
 vector<vector<int>> pathsright;</span>

这是及耗费空间的，而且需要对其中的两个进行插入操作，也是耗时的。 最终运行程序得到的时间是24ms.性能较低，也是符合分析的。

那么我们可不可以不创建如此多的临时变量，可能的想法是将传入的参数变为引用参数，而不是值传参。

或者考虑非递归的方法。

首先考虑非递归的方法: 我们采用非递归的前序遍历，会用一个stack<>储存节点，其存储方式是根左右，当我们找到一个叶子节点时，假如该叶子节点是符合条件，其对应的路径如何从stack中提取出来，这是一个难点。

因此，我们还是考虑递归方法，这是考虑将参数类型改为引用形。

首先我们需要一个vector<int> 存储单条符合条件的路径，还需要一个vector<vector<int>> 储存最终所有符合条件的路径。

假如这两个参数都是递归函数的引用型参数，那么我们自定义的函数为如下样式：

void FindPaths(TreeNode* root,int sum,vector<int>& path,vector<vector<int>>& paths)

具体如何实现这个函数呢？

paths只会在找到一条符合条件的路径path时才会push_back(path);其余时候，paths不会改变。

而递归到叶子节点时，我们希望path已经存入了从根节点到该叶子节点的整条路径，如果该叶子节点的值是满足条件的，那么我们直接将这条path存入paths.否则返回。在返回之前，我们需要弹出path的最后一个元素，也就是该叶子节点。

因此，递归程序的实现如下：

    void FindPaths(TreeNode* root,int sum,vector<int>& path,vector<vector<int>>& paths){
        if(!root) return;
        path.push_back(root->val);
        if(root->val==sum && !root->left && !root->right){
            paths.push_back(path);
        }
        FindPaths(root->left,sum-root->val,path,paths);
        FindPaths(root->right,sum-root->val,path,paths);
        path.pop_back();
    }

最终paths是我们想要的结果。整个程序如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> paths;
        vector<int> path;
        FindPaths(root,sum,path,paths);
        return paths;
    }
    void FindPaths(TreeNode* root,int sum,vector<int>& path,vector<vector<int>>& paths){
        if(!root) return;
        path.push_back(root->val);
        if(root->val==sum && !root->left && !root->right){
            paths.push_back(path);
        }
        FindPaths(root->left,sum-root->val,path,paths);
        FindPaths(root->right,sum-root->val,path,paths);
        path.pop_back();
    }
};