关闭

LeetCode题解——Path Sum II

标签: LeetCodeBinaryTreesumpath
240人阅读 评论(0) 收藏 举报
分类:

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();
    }
};



0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:249142次
    • 积分:4161
    • 等级:
    • 排名:第7683名
    • 原创:159篇
    • 转载:159篇
    • 译文:0篇
    • 评论:44条
    最新评论