Path Sum II

  1. 问题

    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]
    ] 
    
  2. 解答
    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution1 {
    public:
        vector<vector<int>> pathSum(TreeNode* root, int sum) {
     
             vector<int> a;
             path(root,sum,a);
           
            return res;
        }
        void path(TreeNode *root,int sum,vector<int> a)
        {
             if(root)
            {
           // if(root==NULL) return res;
              if(root->left==NULL && root->right==NULL && sum==root->val)
              {
                  a.push_back(root->val);
                  res.push_back(a);
                  //a.clear();
              }
             else
              {
                a.push_back(root->val);
                path(root->left,sum-root->val,a);
                path(root->right,sum-root->val,a);
              }
            }
        }
    public:
       vector<vector<int>> res;
    };
    
    class Solution2 {
    public:
        vector<vector<int>> pathSum(TreeNode* root, int sum) {
     
            // vector<int> a;
             path(root,sum);
           
            return res;
        }
        void path(TreeNode *root,int sum)
        {
             if(root)
            {
           // if(root==NULL) return res;
              if(root->left==NULL && root->right==NULL && sum==root->val)
              {
                  a.push_back(root->val);
                  res.push_back(a);
                  return ;
                  //a.clear();
              }
             else
              {
                   a.push_back(root->val);
                   
                  if(root->left)
                  {
                       
                    path(root->left,sum-root->val);
                    a.pop_back();
                       
                  }
                   
                 if(root->right)
                 {
                    path(root->right,sum-root->val);
                    a.pop_back();
                 }
              }
            }
        }
    public:
       vector<vector<int>> res;
       vector<int> a;
    };
    
    class Solution {
    public:
        Solution():a(1000){}
        vector<vector<int>> pathSum(TreeNode* root, int sum) {
     
             path(root,sum,0);
           
            return res;
        }
        void path(TreeNode *root,int sum,int n)
        {
            if(root==NULL) return ;
             if(root)
            {
               a[n]=root->val;
               n++;
               
              if(root->left==NULL && root->right==NULL && sum==root->val)
              {
                  vector<int> temp(a.begin(),a.begin()+n);
                  res.push_back(temp);
                  return ;
              }
             else
              {
         
                    path(root->left,sum-root->val,n);
         
                    path(root->right,sum-root->val,n);
     
              }
            }
        }
    public:
       vector<vector<int>> res;
       vector<int> a;
    };


阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u012201343/article/details/49947797
文章标签: 二叉树
个人分类: LeetCode
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭