给定树的根节点，找到距离根节点最大深度的所有叶节点的总和。
例子：
1
/ \
2 3
/ \ / \
4 5 6 7
Input : root(of above tree)
Output : 22
Explanation:
Nodes at maximum depth are: 4, 5, 6, 7.
So, sum of these nodes = 22
在上一篇文章中，我们讨论了一种递归解决方案，该解决方案首先找到最大级别，然后找到该级别上存在的所有节点的总和。
在本文中，我们将看到一个没有找到高度或深度的递归解决方案。这个想法是在遍历节点时，将节点的级别与max_level(直到当前节点的最大级别)进行比较。如果当前级别超过最大级别，则将max_level更新为当前级别。如果最大级别和当前级别相同，则将根数据添加到当前总和中，否则，如果级别小于max_level，则不执行任何操作。
下面是上述方法的实现：
C++
// C++ Program to find sum of nodes at maximum
// Depth of the Binary Tree
#include
using namespace std;
// Variables to store sum and
// maximum level
int sum = 0, max_level = INT_MIN;
// Binary Tree Node
struct Node {
int data;
Node* left;
Node* right;
};
// Utility function to create and
// return a new Binary Tree Node
Node* createNode(int val)
{
Node* node = new Node;
node->data = val;
node->left = NULL;
node->right = NULL;
return node;
}
// Function to find the sum of the node which
// are present at the maximum depth
void sumOfNodesAtMaxDepth(Node* root, int level)
{
if (root == NULL)
return;
// If the current level exceeds the
// maximum level, update the max_level
// as current level.
if (level > max_level) {
sum = root->data;
max_level = level;
}
// If the max level and current level
// are same, add the root data to
// current sum.
else if (level == max_level) {
sum = sum + root->data;
}
// Traverse the left and right subtrees
sumOfNodesAtMaxDepth(root->left, level + 1);
sumOfNodesAtMaxDepth(root->right, level + 1);
}
// Driver Code
int main()
{
Node* root;
root = createNode(1);
root->left = createNode(2);
root->right = createNode(3);
root->left->left = createNode(4);
root->left->right = createNode(5);
root->right->left = createNode(6);
root->right->right = createNode(7);
sumOfNodesAtMaxDepth(root, 0);
cout << sum;
return 0;
} Java
// Java Program to find sum of nodes at maximum
// Depth of the Binary Tree
class GfG
{
// Variables to store sum and
// maximum level
static int sum = 0,
max_level = Integer.MIN_VALUE;
// Binary Tree Node
static class Node
{
int data;
Node left;
Node right;
}
// Utility function to create and
// return a new Binary Tree Node
static Node createNode(int val)
{
Node node = new Node();
node.data = val;
node.left = null;
node.right = null;
return node;
}
// Function to find the sum of
// the node which are present
// at the maximum depth
static void sumOfNodesAtMaxDepth(Node root,
int level)
{
if (root == null)
return;
// If the current level exceeds the
// maximum level, update the max_level
// as current level.
if (level > max_level)
{
sum = root.data;
max_level = level;
}
// If the max level and current level
// are same, add the root data to
// current sum.
else if (level == max_level)
{
sum = sum + root.data;
}
// Traverse the left and right subtrees
sumOfNodesAtMaxDepth(root.left, level + 1);
sumOfNodesAtMaxDepth(root.right, level + 1);
}
// Driver Code
public static void main(String[] args)
{
Node root = null;
root = createNode(1);
root.left = createNode(2);
root.right = createNode(3);
root.left.left = createNode(4);
root.left.right = createNode(5);
root.right.left = createNode(6);
root.right.right = createNode(7);
sumOfNodesAtMaxDepth(root, 0);
System.out.println(sum);
}
}
// This code is contributed by
// Prerna Saini.Python3
# Python3 Program to find sum of nodes at maximum
# Depth of the Binary Tree
# Variables to store sum and
# maximum level
sum = [0]
max_level = [-(2**32)]
# Binary tree node
class createNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Function to find the sum of the node which
# are present at the maximum depth
def sumOfNodesAtMaxDepth(root, level):
if (root == None):
return
# If the current level exceeds the
# maximum level, update the max_level
# as current level.
if (level > max_level[0]):
sum[0] = root.data
max_level[0] = level
# If the max level and current level
#are same, add the root data to
# current sum.
elif (level == max_level[0]):
sum[0] = sum[0] + root.data
# Traverse the left and right subtrees
sumOfNodesAtMaxDepth(root.left, level + 1)
sumOfNodesAtMaxDepth(root.right, level + 1)
# Driver Code
root = createNode(1)
root.left = createNode(2)
root.right = createNode(3)
root.left.left = createNode(4)
root.left.right = createNode(5)
root.right.left = createNode(6)
root.right.right = createNode(7)
sumOfNodesAtMaxDepth(root, 0)
print(sum[0])
# This code is contributed by SHUBHAMSINGH10C#
// C# Program to find sum of nodes at maximum
// Depth of the Binary Tree
using System;
public class GfG
{
// Variables to store sum and
// maximum level
static int sum = 0,
max_level = int.MinValue;
// Binary Tree Node
class Node
{
public int data;
public Node left;
public Node right;
}
// Utility function to create and
// return a new Binary Tree Node
static Node createNode(int val)
{
Node node = new Node();
node.data = val;
node.left = null;
node.right = null;
return node;
}
// Function to find the sum of
// the node which are present
// at the maximum depth
static void sumOfNodesAtMaxDepth(Node root,
int level)
{
if (root == null)
return;
// If the current level exceeds the
// maximum level, update the max_level
// as current level.
if (level > max_level)
{
sum = root.data;
max_level = level;
}
// If the max level and current level
// are same, add the root data to
// current sum.
else if (level == max_level)
{
sum = sum + root.data;
}
// Traverse the left and right subtrees
sumOfNodesAtMaxDepth(root.left, level + 1);
sumOfNodesAtMaxDepth(root.right, level + 1);
}
// Driver Code
public static void Main()
{
Node root = null;
root = createNode(1);
root.left = createNode(2);
root.right = createNode(3);
root.left.left = createNode(4);
root.left.right = createNode(5);
root.right.left = createNode(6);
root.right.right = createNode(7);
sumOfNodesAtMaxDepth(root, 0);
Console.WriteLine(sum);
}
}
/* This code is contributed PrinciRaj1992 */输出：
22
如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。