Skip to content
Related Articles

Related Articles

Sum of all nodes in a binary tree

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 18 Jul, 2022
Improve Article
Save Article

Give an algorithm for finding the sum of all elements in a binary tree.
 

In the above binary tree sum = 106. 

The idea is to recursively, call left subtree sum, right subtree sum and add their values to current node’s data. 

Implementation:

C++




/* Program to print sum of all the elements of a binary tree */
#include <bits/stdc++.h>
using namespace std;
 
struct Node {
    int key;
    Node* left, *right;
};
 
/* utility that allocates a new Node with the given key  */
Node* newNode(int key)
{
    Node* node = new Node;
    node->key = key;
    node->left = node->right = NULL;
    return (node);
}
 
/* Function to find sum of all the elements*/
int addBT(Node* root)
{
    if (root == NULL)
        return 0;
    return (root->key + addBT(root->left) + addBT(root->right));
}
 
/* Driver program to test above functions*/
int main()
{
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->left = newNode(6);
    root->right->right = newNode(7);
    root->right->left->right = newNode(8);
 
    int sum = addBT(root);
    cout << "Sum of all the elements is: " << sum << endl;
 
    return 0;
}

Java




// Java Program to print sum of
// all the elements of a binary tree
class GFG
{
static class Node
{
    int key;
    Node left, right;
}
 
/* utility that allocates a new
   Node with the given key */
static Node newNode(int key)
{
    Node node = new Node();
    node.key = key;
    node.left = node.right = null;
    return (node);
}
 
/* Function to find sum
   of all the elements*/
static int addBT(Node root)
{
    if (root == null)
        return 0;
    return (root.key + addBT(root.left) +
                       addBT(root.right));
}
 
// Driver Code
public static void main(String args[])
{
    Node root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.left.right = newNode(5);
    root.right.left = newNode(6);
    root.right.right = newNode(7);
    root.right.left.right = newNode(8);
 
    int sum = addBT(root);
    System.out.println("Sum of all the elements is: " + sum);
}
}
 
// This code is contributed by Arnab Kundu

Python3




# Python3 Program to print sum of all
# the elements of a binary tree
 
# Binary Tree Node
 
""" utility that allocates a new Node
with the given key """
class newNode:
 
    # Construct to create a new node
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None
         
# Function to find sum of all the element
def addBT(root):
    if (root == None):
        return 0
    return (root.key + addBT(root.left) +
                       addBT(root.right))
 
# Driver Code
if __name__ == '__main__':
    root = newNode(1)
    root.left = newNode(2)
    root.right = newNode(3)
    root.left.left = newNode(4)
    root.left.right = newNode(5)
    root.right.left = newNode(6)
    root.right.right = newNode(7)
    root.right.left.right = newNode(8)
 
    sum = addBT(root)
 
    print("Sum of all the nodes is:", sum)
 
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

C#




using System;
 
// C# Program to print sum of
// all the elements of a binary tree
public class GFG
{
public class Node
{
    public int key;
    public Node left, right;
}
 
/* utility that allocates a new 
   Node with the given key */
public static Node newNode(int key)
{
    Node node = new Node();
    node.key = key;
    node.left = node.right = null;
    return (node);
}
 
/* Function to find sum 
   of all the elements*/
public static int addBT(Node root)
{
    if (root == null)
    {
        return 0;
    }
    return (root.key + addBT(root.left) + addBT(root.right));
}
 
// Driver Code
public static void Main(string[] args)
{
    Node root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.left.right = newNode(5);
    root.right.left = newNode(6);
    root.right.right = newNode(7);
    root.right.left.right = newNode(8);
 
    int sum = addBT(root);
    Console.WriteLine("Sum of all the elements is: " + sum);
}
}
 
// This code is contributed by Shrikant13

Javascript




<script>
// Javascript Program to print sum of
// all the elements of a binary tree
 
class Node
{   
    constructor(key)
    {
        this.key=key;
        this.left=this.right=null;
    }
}
 
/* Function to find sum
   of all the elements*/
function addBT(root)
{
    if (root == null)
        return 0;
    return (root.key + addBT(root.left) +
                       addBT(root.right));
}
 
// Driver Code
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.right.left.right = new Node(8);
 
let sum = addBT(root);
document.write("Sum of all the elements is: " + sum);
 
// This code is contributed by avanitrachhadiya2155
</script>

Output

Sum of all the elements is: 36

Method 2 – Another way to solve this problem is by using Level Order Traversal. Every time when a Node is deleted from the queue, add it to the sum variable.

Implementation:

C++




#include <bits/stdc++.h>
#include <iostream>
using namespace std;
 
struct Node {
    int key;
    struct Node *left, *right;
};
 
// Utility function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return (temp);
}
 
/*Function to find sum of all elements*/
int sumBT(Node* root)
{
      //sum variable to track the sum of
      //all variables.
    int sum = 0;
   
    queue<Node*> q;
 
      //Pushing the first level.
    q.push(root);
 
      //Pushing elements at each level from
      //the tree.
    while (!q.empty()) {
        Node* temp = q.front();
        q.pop();
       
          //After popping each element from queue
          //add its data to the sum variable.
        sum += temp->key;
 
        if (temp->left) {
            q.push(temp->left);
        }
        if (temp->right) {
            q.push(temp->right);
        }
    }
    return sum;
}
 
// Driver program
int main()
{
    // Let us create Binary Tree shown in above example
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->left = newNode(6);
    root->right->right = newNode(7);
    root->right->left->right = newNode(8);
 
    cout << "Sum of all elements in the binary tree is: "
         << sumBT(root);
}
 
//This code is contributed by Sarthak Delori

Java




// Java Program to print sum of
// all the elements of a binary tree
import java.util.LinkedList;
import java.util.Queue;
 
class GFG {
    static class Node {
        int key;
        Node left, right;
    }
 
    // Utility function to create a new node
    static Node newNode(int key)
    {
        Node node = new Node();
        node.key = key;
        node.left = node.right = null;
        return (node);
    }
 
    /*Function to find sum of all elements*/
    static int sumBT(Node root)
    {
        // sum variable to track the sum of
        // all variables.
        int sum = 0;
 
        Queue<Node> q = new LinkedList<Node>();
 
        // Pushing the first level.
        q.add(root);
 
        // Pushing elements at each level from
        // the tree.
        while (!q.isEmpty()) {
            Node temp = q.poll();
 
            // After popping each element from queue
            // add its data to the sum variable.
            sum += temp.key;
 
            if (temp.left != null) {
                q.add(temp.left);
            }
            if (temp.right != null) {
                q.add(temp.right);
            }
        }
        return sum;
    }
 
    // Driver Code
    public static void main(String args[])
    {
        Node root = newNode(1);
        root.left = newNode(2);
        root.right = newNode(3);
        root.left.left = newNode(4);
        root.left.right = newNode(5);
        root.right.left = newNode(6);
        root.right.right = newNode(7);
        root.right.left.right = newNode(8);
 
        int sum = sumBT(root);
        System.out.println(
            "Sum of all elements in the binary tree is: "
            + sum);
    }
}
 
// This code is contributed by Abhijeet Kumar(abhijeet19403)

Python3




# Python3 Program to print sum of all
# the elements of a binary tree
 
# Binary Tree Node
class newNode:
 
    # Utility function to create a new node
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None
 
# Function to find sum of all the element
def sumBT(root):
    # sum variable to track the sum of
    # all variables.
    sum = 0
 
    q = []
 
    # Pushing the first level.
    q.append(root)
 
    # Pushing elements at each level from
    # the tree.
    while len(q) > 0:
        temp = q.pop(0)
 
        # After popping each element from queue
        # add its data to the sum variable.
        sum += temp.key
 
        if (temp.left != None):
            q.append(temp.left)
        if temp.right != None:
            q.append(temp.right)
 
    return sum
 
 
# Driver Code
if __name__ == '__main__':
    root = newNode(1)
    root.left = newNode(2)
    root.right = newNode(3)
    root.left.left = newNode(4)
    root.left.right = newNode(5)
    root.right.left = newNode(6)
    root.right.right = newNode(7)
    root.right.left.right = newNode(8)
 
    print("Sum of all elements in the binary tree is: ", sumBT(root))
 
# This code is contributed by
# Abhijeet Kumar(abhijeet19403)

C#




// C# Program to print sum of
// all the elements of a binary tree
 
using System;
using System.Collections.Generic;
 
public class GFG {
    public class Node {
        public int key;
        public Node left, right;
    }
 
    // Utility function to create a new node
    public static Node newNode(int key)
    {
        Node node = new Node();
        node.key = key;
        node.left = node.right = null;
        return (node);
    }
 
    /*Function to find sum of all elements*/
    public static int sumBT(Node root)
    {
        // sum variable to track the sum of
        // all variables.
        int sum = 0;
 
        Queue<Node> q = new Queue<Node>();
 
        // Pushing the first level.
        q.Enqueue(root);
 
        // Pushing elements at each level from
        // the tree.
        while (q.Count!=0) {
            Node temp = q.Dequeue();
 
            // After popping each element from queue
            // add its data to the sum variable.
            sum += temp.key;
 
            if (temp.left != null) {
                q.Enqueue(temp.left);
            }
            if (temp.right != null) {
                q.Enqueue(temp.right);
            }
        }
        return sum;
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        Node root = newNode(1);
        root.left = newNode(2);
        root.right = newNode(3);
        root.left.left = newNode(4);
        root.left.right = newNode(5);
        root.right.left = newNode(6);
        root.right.right = newNode(7);
        root.right.left.right = newNode(8);
 
        Console.WriteLine("Sum of all elements in the binary tree is: "
                          + sumBT(root));
    }
}
 
// This code is contributed by Abhijeet Kumar(abhijeet19403)

Javascript




<script>
// Javascript Program to print sum of
// all the elements of a binary tree
 
class Node
{  
    // Utility function to create a new node
    constructor(key)
    {
        this.key=key;
        this.left=this.right=null;
    }
}
 
/* Function to find sum
   of all the elements*/
function sumBT(root)
{
    // sum variable to track the sum of
    // all variables.
    let sum = 0;
 
    let q = [];
 
    // Pushing the first level.
    q.push(root);
 
    // Pushing elements at each level from
    // the tree.
    while (q.length != 0) {
        let temp = q.shift();
        // After popping each element from queue
        // add its data to the sum variable.
        sum += temp.key;
 
        if (temp.left != null) {
            q.add(temp.left);
        }
        if (temp.right != null) {
            q.add(temp.right);
        }
    }
    return sum;
}
 
// Driver Code
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);
root.right.left.right = new Node(8);
  
document.write("Sum of all elements in the binary tree is: " + sumBT(root));
 
// This code is contributed by Abhijeet Kumar(abhijeet19403)
</script>

Output

Sum of all elements in the binary tree is: 36

Time Complexity: O(n)
Auxiliary Space: O(n)

This article is contributed by Prakriti Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!