LeetCode题解——Path Sum II

原创 2015年11月18日 19:15:24

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



版权声明:本文为博主原创文章,未经博主允许不得转载。

【LeetCode-面试算法经典-Java实现】【113-Path Sum II(路径和)】

【113-Path Sum II(路径和II)】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题  Given a binary tree and a sum, find al...
  • DERRANTCM
  • DERRANTCM
  • 2015年08月12日 06:23
  • 2506

【LeetCode-面试算法经典-Java实现】【064-Minimum Path Sum(最小路径和)】

【064-Minimum Path Sum(最小路径和)】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题  Given a m x n grid filled with no...
  • DERRANTCM
  • DERRANTCM
  • 2015年08月02日 06:05
  • 2290

leetcode Path Sum II 关于树的后序遍历

我们利用辅助栈来进行树的houxi
  • u012724887
  • u012724887
  • 2014年09月29日 15:12
  • 255

Max Sum(最大子段和问题)

最大子段和:给定一个序列(元素可正可负),找出其子序列中和最大的值。 我们用dp(i)表示序列中以元素ans(i)结尾的序列的最大子段和,那么有:dp(i)=max(dp)...
  • AC_Gibson
  • AC_Gibson
  • 2014年12月04日 16:54
  • 994

LeetCode-分类题解

https://github.com/soulmachine/leetcode/raw/master/C%2B%2B/leetcode-cpp.pdf 原作者:戴方勤(soulmachine@gma...
  • skp127
  • skp127
  • 2016年07月03日 14:53
  • 1014

Leetcode 454. 4Sum II 四数之和2 解题报告

1 解题思想首先,这是一道远古之前的题的进化版: Leetcode #18 4Sum 四数之和 解题小节+K-Sum思想 但是我不想说那个题了,因为我也记不住了。。这道题意思就是ABCD四个数组,长...
  • MebiuW
  • MebiuW
  • 2016年11月16日 22:45
  • 2778

本博客LeetCode题解索引及各类算法问题小结汇总(C++实现)

Some explains: 1),The current problems have been solved:Welcome, EbowTang! You have solved 101 / 316...
  • EbowTang
  • EbowTang
  • 2016年02月15日 17:18
  • 5504

【LeetCode-面试算法经典-Java实现】【所有题目目录索引】

【博文总目录>>>】 LeetCode算法题典   LeetCode是一个准备面试非常有用的网站,是非常值得去的地方,里面都是一些经典的面试题,这些题目在Google,Microsof...
  • DERRANTCM
  • DERRANTCM
  • 2015年07月16日 06:27
  • 24582

LeetCode题解整理版(一)

Evaluate Reverse Polish Notation 逆波兰表达式求值,经典问题。 遇到数字入栈,遇到符号取栈顶的两个出来运算,再将结果入栈,最后栈里剩下的一个元素就是结果了。 ...
  • xualaleilei
  • xualaleilei
  • 2016年04月04日 17:30
  • 436

算法:经典leetcode算法题解

1. Patching Array 补丁数组(考虑ing) 原题描述:https://leetcode.com/problems/patching-array/ 给定一个有序正整数数组nums以及...
  • ztf312
  • ztf312
  • 2016年03月30日 13:50
  • 967
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:LeetCode题解——Path Sum II
举报原因:
原因补充:

(最多只允许输入30个字)