给定一棵二叉树，任务是打印给定二叉树的所有根到叶路径总和。
例子：
Input:
30
/ \
10 50
/ \ / \
3 16 40 60
Output: 43 56 120 140
Explanation:
In the above binary tree
there are 4 leaf nodes.
Hence, total 4 path sum are
present from root node to the
leaf node.
(i.e., 30-10-3, 30-10-16,
30-50-40, 30-50-60)
Therefore, the path sums from
left to right would be
(43, 56, 120, 140).
Input:
11
/ \
12 5
\ /
16 40
Output: 39 56
Explanation:
In the above binary tree
there are 2 leaf nodes.
Hence, total 2 path sum are
present from root node to
the leaf node.
(i.e 11-12-16, 11-5-40)
Therefore, the path sums from
left to right would be (39 56).方法：思路是使用DFS Traversal从二叉树的根到叶遍历，计算每个根到叶路径的总和。请按照以下步骤解决问题：
- 从初始路径和为 0 的二叉树的根节点开始。
- 将当前节点的值添加到路径总和中。
- 用路径总和的当前值，前往当前节点的左右子节点。
- 对二叉树的所有后续节点重复步骤 2 和 3。
- 在到达叶节点时，将路径总和添加到pathSum的向量中。
- 打印向量pathSum 的所有元素作为输出。
下面是上述方法的实现：
C++14
// C++ program for the above approach
#include
using namespace std;
// TreeNode structure
struct TreeNode {
int val;
TreeNode *left, *right;
};
// Function that returns a new TreeNode
// with given value
struct TreeNode* addNode(int data)
{
// Allocate memory
struct TreeNode* node
= (struct TreeNode*)malloc(
sizeof(struct TreeNode));
// Assign data to val variable
node->val = data;
node->left = NULL;
node->right = NULL;
return node;
};
// Function that calculates the root to
// leaf path sum of the BT using DFS
void dfs(TreeNode* root, int sum,
vector& pathSum)
{
// Return if the node is NULL
if (root == NULL)
return;
// Add value of the node to
// the path sum
sum += root->val;
// Store the path sum if node is leaf
if (root->left == NULL
and root->right == NULL) {
pathSum.push_back(sum);
return;
}
// Move to the left child
dfs(root->left, sum, pathSum);
// Move to the right child
dfs(root->right, sum, pathSum);
}
// Function that finds the root to leaf
// path sum of the given binary tree
void findPathSum(TreeNode* root)
{
// To store all the path sum
vector pathSum;
// Calling dfs function
dfs(root, 0, pathSum);
// Printing all the path sum
for (int num : pathSum) {
cout << num << " ";
}
cout << endl;
}
// Driver Code
int main()
{
// Given binary tree
TreeNode* root = addNode(30);
root->left = addNode(10);
root->right = addNode(50);
root->left->left = addNode(3);
root->left->right = addNode(16);
root->right->left = addNode(40);
root->right->right = addNode(60);
/* The above code constructs this tree
30
/ \
10 50
/ \ / \
3 16 40 60
*/
// Function Call
findPathSum(root);
return 0;
} Java
// Java program for the above approach
import java.util.*;
class GFG{
// Structure of
// binary tree node
static class Node
{
int val;
Node left, right;
};
// Function to create new node
static Node newNode(int data)
{
Node temp = new Node();
temp.val = data;
temp.left = temp.right = null;
return temp;
}
// Function that calculates the root to
// leaf path sum of the BT using DFS
static void dfs(Node root, int sum,
ArrayList pathSum)
{
// Return if the node is NULL
if (root == null)
return;
// Add value of the node to
// the path sum
sum += root.val;
// Store the path sum if node is leaf
if (root.left == null &&
root.right == null)
{
pathSum.add(sum);
return;
}
// Move to the left child
dfs(root.left, sum, pathSum);
// Move to the right child
dfs(root.right, sum, pathSum);
}
// Function that finds the root to leaf
// path sum of the given binary tree
static void findPathSum(Node root)
{
// To store all the path sum
ArrayList pathSum = new ArrayList<>();
// Calling dfs function
dfs(root, 0, pathSum);
// Printing all the path sum
for(int num : pathSum)
{
System.out.print(num + " ");
}
}
// Driver code
public static void main(String[] args)
{
// Construct binary tree
Node root = newNode(30);
root.left = newNode(10);
root.right = newNode(50);
root.left.left = newNode(3);
root.left.right = newNode(16);
root.right.left = newNode(40);
root.right.right = newNode(60);
/* The above code constructs this tree
30
/ \
10 50
/ \ / \
3 16 40 60
*/
// Function call
findPathSum(root);
}
}
// This code is contributed by offbeat Python3
# Python3 program for the
# above approach
from collections import deque
# A Tree node
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
pathSum = []
# Function that calculates
# the root to leaf path
# sum of the BT using DFS
def dfs(root, sum):
# Return if the node
# is NULL
if (root == None):
return
# Add value of the node to
# the path sum
sum += root.data
# Store the path sum if
# node is leaf
if (root.left == None and
root.right == None):
pathSum.append(sum)
return
# Move to the left child
dfs(root.left, sum)
# Move to the right child
dfs(root.right, sum)
# Function that finds the
# root to leaf path sum
# of the given binary tree
def findPathSum(root):
# To store all the path sum
# vector pathSum
# Calling dfs function
dfs(root, 0)
# Printing all the path sum
for num in pathSum:
print(num, end = " ")
# Driver Code
if __name__ == '__main__':
# Given binary tree
root = Node(30)
root.left = Node(10)
root.right = Node(50)
root.left.left = Node(3)
root.left.right = Node(16)
root.right.left = Node(40)
root.right.right = Node(60)
# /* The above code constructs this tree
#
# 30
# / \
# 10 50
# / \ / \
# 3 16 40 60
# */
# Function Call
findPathSum(root)
# This code is contributed by Mohit Kumar 29 C#
// C# program for the above approach
using System;
using System.Collections.Generic;
// Structure of
// binary tree node
public class Node
{
public int val;
public Node left, right;
public Node(int item)
{
val = item;
left = right = null;
}
}
public class BinaryTree
{
public static Node node;
// Function that calculates the root to
// leaf path sum of the BT using DFS
static void dfs(Node root, int sum, List pathSum)
{
// Return if the node is NULL
if (root == null)
{
return;
}
// Add value of the node to
// the path sum
sum += root.val;
// Store the path sum if node is leaf
if(root.left == null && root.right == null)
{
pathSum.Add(sum);
return;
}
// Move to the left child
dfs(root.left, sum, pathSum);
// Move to the right child
dfs(root.right, sum, pathSum);
}
// Function that finds the root to leaf
// path sum of the given binary tree
static void findPathSum(Node root)
{
// To store all the path sum
List pathSum = new List();
// Calling dfs function
dfs(root, 0, pathSum);
// Printing all the path sum
foreach(int num in pathSum)
{
Console.Write(num + " ");
}
}
// Driver code
static public void Main ()
{
// Construct binary tree
BinaryTree.node = new Node(30);
BinaryTree.node.left = new Node(10);
BinaryTree.node.right = new Node(50);
BinaryTree.node.left.left = new Node(3);
BinaryTree.node.left.right = new Node(16);
BinaryTree.node.right.left = new Node(40);
BinaryTree.node.right.right = new Node(60);
/* The above code constructs this tree
30
/ \
10 50
/ \ / \
3 16 40 60
*/
// Function call
findPathSum(node);
}
}
// This code is contributed by avanitrachhadiya2155 输出：
43 56 120 140时间复杂度： O(N)
辅助空间： O(N)
如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live