🔥 ข่าวด่วน: web//https://www.geeksforgeeks.org/check sum covered uncovered nodes binary tree

Given a binary tree, you need to check whether sum of all covered elements is equal to sum of all uncovered elements or not.
In a binary tree, a node is called Uncovered if it appears either on left boundary or right boundary. Rest of the nodes are called covered.

For example, consider below binary tree


In above binary tree,
Covered node:     6, 5, 7
Uncovered node:   9, 4, 3, 17, 22, 20

The output for this tree should be false as 
sum of covered and uncovered node is not same

We strongly recommend you to minimize your browser and try this yourself first.

For calculating sum of Uncovered nodes we will follow below steps:
1) Start from root, go to left and keep going until left child is available, if not go to right child and again follow same procedure until you reach a leaf node.

2) After step 1 sum of left boundary will be stored, now for right part again do the same procedure but now keep going to right until right child is available, if not then go to left child and follow same procedure until you reach a leaf node.

After above 2 steps sum of all Uncovered node will be stored, we can subtract it from total sum and get sum of covered elements and check for equines of binary tree.

C++

// C++ program to find sum of Covered and Uncovered node of 
// binary tree 
#include <bits/stdc++.h> 
using namespace std; 
  
/* A binary tree node has key, pointer to left 
   child and a pointer to right child */
struct Node 
{ 
    int key; 
    struct Node* left, *right; 
}; 
  
/* To create a newNode of tree and return pointer */
struct Node* newNode(int key) 
{ 
    Node* temp = new Node; 
    temp->key = key; 
    temp->left = temp->right = NULL; 
    return (temp); 
} 
  
/* Utility function to calculate sum of all node of tree */
int sum(Node* t) 
{ 
    if (t == NULL) 
        return 0; 
    return t->key + sum(t->left) + sum(t->right); 
} 
  
/* Recursive function to calculate sum of left boundary 
   elements  */
int uncoveredSumLeft(Node* t) 
{ 
    /*  If leaf node, then just return its key value   */
    if (t->left == NULL && t->right == NULL) 
        return t->key; 
  
    /*  If left is available then go left otherwise go right  */
    if (t->left != NULL) 
        return t->key + uncoveredSumLeft(t->left); 
    else
        return t->key + uncoveredSumLeft(t->right); 
} 
  
/* Recursive function to calculate sum of right boundary 
   elements  */
int uncoveredSumRight(Node* t) 
{ 
    /*  If leaf node, then just return its key value   */
    if (t->left == NULL && t->right == NULL) 
        return t->key; 
  
    /*  If right is available then go right otherwise go left  */
    if (t->right != NULL) 
        return t->key + uncoveredSumRight(t->right); 
    else
        return t->key + uncoveredSumRight(t->left); 
} 
  
// Returns sum of uncovered elements 
int uncoverSum(Node* t) 
{ 
    /* Initializing with 0 in case we don't have 
       left or right boundary  */
    int lb = 0, rb = 0; 
  
    if (t->left != NULL) 
        lb = uncoveredSumLeft(t->left); 
    if (t->right != NULL) 
        rb = uncoveredSumRight(t->right); 
  
    /* returning sum of root node, left boundary 
       and right boundary*/
    return t->key + lb + rb; 
} 
  
// Returns true if sum of covered and uncovered elements 
// is same. 
bool isSumSame(Node *root) 
{ 
    // Sum of uncovered elements 
    int sumUC = uncoverSum(root); 
  
    // Sum of all elements 
    int sumT = sum(root); 
  
    // Check if sum of covered and uncovered is same 
    return (sumUC == (sumT - sumUC)); 
} 
  
/* Helper function to print inorder traversal of 
   binary tree   */
void inorder(Node* root) 
{ 
    if (root) 
    { 
        inorder(root->left); 
        printf("%d ", root->key); 
        inorder(root->right); 
    } 
} 
  
// Driver program to test above functions 
int main() 
{ 
    // Making above given diagram's binary tree 
    Node* root = newNode(8); 
    root->left = newNode(3); 
  
    root->left->left = newNode(1); 
    root->left->right = newNode(6); 
    root->left->right->left = newNode(4); 
    root->left->right->right = newNode(7); 
  
    root->right = newNode(10); 
    root->right->right = newNode(14); 
    root->right->right->left = newNode(13); 
  
    if (isSumSame(root)) 
        printf("Sum of covered and uncovered is same\n"); 
    else
        printf("Sum of covered and uncovered is not same\n"); 
}

Java

// Java program to find sum of covered and uncovered nodes 
// of a binary tree  
  
/* A binary tree node has key, pointer to left child and 
   a pointer to right child */
class Node  
{ 
    int key; 
    Node left, right; 
  
    public Node(int key)  
    { 
        this.key = key; 
        left = right = null; 
    } 
} 
  
class BinaryTree  
{ 
    Node root; 
  
    /* Utility function to calculate sum of all node of tree */
    int sum(Node t)  
    { 
        if (t == null)  
            return 0; 
        return t.key + sum(t.left) + sum(t.right); 
    } 
  
    /* Recursive function to calculate sum of left boundary 
       elements  */
    int uncoveredSumLeft(Node t)  
    { 
        /*  If left node, then just return its key value   */
        if (t.left == null && t.right == null) 
            return t.key; 
  
        /*  If left is available then go left otherwise go right  */
        if (t.left != null)  
            return t.key + uncoveredSumLeft(t.left); 
         else 
            return t.key + uncoveredSumLeft(t.right); 
    } 
  
    /* Recursive function to calculate sum of right boundary 
       elements  */
    int uncoveredSumRight(Node t)  
    { 
        /*  If left node, then just return its key value   */
        if (t.left == null && t.right == null) 
            return t.key; 
  
        /*  If right is available then go right otherwise go left  */
        if (t.right != null) 
            return t.key + uncoveredSumRight(t.right); 
        else
            return t.key + uncoveredSumRight(t.left); 
    } 
  
    // Returns sum of uncovered elements 
    int uncoverSum(Node t)  
    { 
        /* Initializing with 0 in case we don't have 
           left or right boundary  */
        int lb = 0, rb = 0; 
  
        if (t.left != null) 
            lb = uncoveredSumLeft(t.left); 
        if (t.right != null) 
            rb = uncoveredSumRight(t.right); 
  
        /* returning sum of root node, left boundary 
           and right boundary*/
        return t.key + lb + rb; 
    } 
  
    // Returns true if sum of covered and uncovered elements 
    // is same. 
    boolean isSumSame(Node root)  
    { 
        // Sum of uncovered elements 
        int sumUC = uncoverSum(root); 
  
        // Sum of all elements 
        int sumT = sum(root); 
  
        // Check if sum of covered and uncovered is same 
        return (sumUC == (sumT - sumUC)); 
    } 
  
    /* Helper function to print inorder traversal of 
       binary tree   */
    void inorder(Node root)  
    { 
        if (root != null)  
        { 
            inorder(root.left); 
            System.out.print(root.key + " "); 
            inorder(root.right); 
        } 
    } 
  
    // Driver program to test above functions 
    public static void main(String[] args)  
    { 
  
        BinaryTree tree = new BinaryTree(); 
  
        // Making above given diagram's binary tree 
        tree.root = new Node(8); 
        tree.root.left = new Node(3); 
        tree.root.left.left = new Node(1); 
        tree.root.left.right = new Node(6); 
        tree.root.left.right.left = new Node(4); 
        tree.root.left.right.right = new Node(7); 
  
        tree.root.right = new Node(10); 
        tree.root.right.right = new Node(14); 
        tree.root.right.right.left = new Node(13); 
  
        if (tree.isSumSame(tree.root))  
            System.out.println("Sum of covered and uncovered is same"); 
         else 
            System.out.println("Sum of covered and uncovered is not same"); 
    } 
} 
  
// This code has been contributed by Mayank Jaiswal(mayank_24) 

Python3

# Python3 program to find sum of Covered and  
# Uncovered node of binary tree  
  
# To create a newNode of tree and return pointer  
class newNode: 
    def __init__(self, key): 
        self.key = key  
        self.left = self.right = None
  
# Utility function to calculate sum  
# of all node of tree  
def Sum(t): 
    if (t == None): 
        return 0
    return t.key + Sum(t.left) + Sum(t.right) 
  
# Recursive function to calculate sum  
# of left boundary elements  
def uncoveredSumLeft(t): 
      
    # If leaf node, then just return  
    # its key value  
    if (t.left == None and t.right == None):  
        return t.key  
  
    # If left is available then go  
    # left otherwise go right  
    if (t.left != None):  
        return t.key + uncoveredSumLeft(t.left)  
    else: 
        return t.key + uncoveredSumLeft(t.right) 
  
# Recursive function to calculate sum of  
# right boundary elements  
def uncoveredSumRight(t): 
      
    # If leaf node, then just return 
    # its key value  
    if (t.left == None and t.right == None):  
        return t.key  
  
    # If right is available then go right 
    # otherwise go left  
    if (t.right != None): 
        return t.key + uncoveredSumRight(t.right)  
    else: 
        return t.key + uncoveredSumRight(t.left) 
  
# Returns sum of uncovered elements  
def uncoverSum(t): 
      
    # Initializing with 0 in case we  
    # don't have left or right boundary  
    lb = 0
    rb = 0
  
    if (t.left != None): 
        lb = uncoveredSumLeft(t.left)  
    if (t.right != None):  
        rb = uncoveredSumRight(t.right)  
  
    # returning sum of root node,  
    # left boundary and right boundary 
    return t.key + lb + rb  
  
# Returns true if sum of covered and  
# uncovered elements is same.  
def isSumSame(root): 
      
    # Sum of uncovered elements  
    sumUC = uncoverSum(root)  
  
    # Sum of all elements  
    sumT = Sum(root)  
  
    # Check if sum of covered and  
    # uncovered is same 
    return (sumUC == (sumT - sumUC)) 
  
# Helper function to prinorder  
# traversal of binary tree  
def inorder(root): 
    if (root): 
        inorder(root.left)  
        print(root.key, end = " ")  
        inorder(root.right) 
  
# Driver Code 
if __name__ == '__main__': 
      
    # Making above given diagram's  
    # binary tree  
    root = newNode(8)  
    root.left = newNode(3)  
  
    root.left.left = newNode(1)  
    root.left.right = newNode(6)  
    root.left.right.left = newNode(4)  
    root.left.right.right = newNode(7)  
  
    root.right = newNode(10)  
    root.right.right = newNode(14)  
    root.right.right.left = newNode(13)  
  
    if (isSumSame(root)):  
        print("Sum of covered and uncovered is same")  
    else: 
        print("Sum of covered and uncovered is not same") 
          
# This code is contributed by PranchalK 

C#

// C# program to find sum of covered  
// and uncovered nodes of a binary tree  
using System; 
  
/* A binary tree node has key, pointer 
to left child and a pointer to right child */
public class Node 
{ 
    public int key; 
    public Node left, right; 
  
    public Node(int key) 
    { 
        this.key = key; 
        left = right = null; 
    } 
} 
  
class GFG 
{ 
public Node root; 
  
/* Utility function to calculate  
sum of all node of tree */
public virtual int sum(Node t) 
{ 
    if (t == null) 
    { 
        return 0; 
    } 
    return t.key + sum(t.left) +  
                   sum(t.right); 
} 
  
/* Recursive function to calculate  
sum of left boundary elements */
public virtual int uncoveredSumLeft(Node t) 
{ 
    /* If left node, then just return 
       its key value */
    if (t.left == null && t.right == null) 
    { 
        return t.key; 
    } 
  
    /* If left is available then go 
       left otherwise go right */
    if (t.left != null) 
    { 
        return t.key + uncoveredSumLeft(t.left); 
    } 
    else
    { 
        return t.key + uncoveredSumLeft(t.right); 
    } 
} 
  
/* Recursive function to calculate  
   sum of right boundary elements */
public virtual int uncoveredSumRight(Node t) 
{ 
    /* If left node, then just return  
       its key value */
    if (t.left == null && t.right == null) 
    { 
        return t.key; 
    } 
  
    /* If right is available then go 
       right otherwise go left */
    if (t.right != null) 
    { 
        return t.key + uncoveredSumRight(t.right); 
    } 
    else
    { 
        return t.key + uncoveredSumRight(t.left); 
    } 
} 
  
// Returns sum of uncovered elements  
public virtual int uncoverSum(Node t) 
{ 
    /* Initializing with 0 in case we  
    don't have left or right boundary */
    int lb = 0, rb = 0; 
  
    if (t.left != null) 
    { 
        lb = uncoveredSumLeft(t.left); 
    } 
    if (t.right != null) 
    { 
        rb = uncoveredSumRight(t.right); 
    } 
  
    /* returning sum of root node,  
    left boundary and right boundary*/
    return t.key + lb + rb; 
} 
  
// Returns true if sum of covered  
// and uncovered elements is same.  
public virtual bool isSumSame(Node root) 
{ 
    // Sum of uncovered elements  
    int sumUC = uncoverSum(root); 
  
    // Sum of all elements  
    int sumT = sum(root); 
  
    // Check if sum of covered and 
    // uncovered is same  
    return (sumUC == (sumT - sumUC)); 
} 
  
/* Helper function to print inorder  
traversal of binary tree */
public virtual void inorder(Node root) 
{ 
    if (root != null) 
    { 
        inorder(root.left); 
        Console.Write(root.key + " "); 
        inorder(root.right); 
    } 
} 
  
// Driver Code 
public static void Main(string[] args) 
{ 
  
    GFG tree = new GFG(); 
  
    // Making above given diagram's binary tree  
    tree.root = new Node(8); 
    tree.root.left = new Node(3); 
    tree.root.left.left = new Node(1); 
    tree.root.left.right = new Node(6); 
    tree.root.left.right.left = new Node(4); 
    tree.root.left.right.right = new Node(7); 
  
    tree.root.right = new Node(10); 
    tree.root.right.right = new Node(14); 
    tree.root.right.right.left = new Node(13); 
  
    if (tree.isSumSame(tree.root)) 
    { 
        Console.WriteLine("Sum of covered and " + 
                            "uncovered is same"); 
    } 
    else
    { 
        Console.WriteLine("Sum of covered and " +  
                        "uncovered is not same"); 
    } 
} 
} 
  
// This code is contributed by Shrikant13 

Output :

Sum of covered and uncovered is not same

This article is contributed by Utkarsh Trivedi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Aug	SEP	Oct
	26
2019	2020	2021

Check sum of Covered and Uncovered nodes of Binary Tree

C++

Java

Python3

C#

Recommended Posts: