Related Articles
Check for Children Sum Property in a Binary Tree
• Difficulty Level : Easy
• Last Updated : 03 Apr, 2019

Given a binary tree, write a function that returns true if the tree satisfies below property.

For every node, data value must be equal to sum of data values in left and right children. Consider data value as 0 for NULL children. Below tree is an example ## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Algorithm:
Traverse the given binary tree. For each node check (recursively) if the node and both its children satisfy the Children Sum Property, if so then return true else return false.

Implementation:

## C++

 `/* Program to check children sum property */``#include ``using` `namespace` `std;`` ` `/* A binary tree node has data, left ``child and right child */``struct` `node``{``    ``int` `data;``    ``struct` `node* left;``    ``struct` `node* right;``};`` ` `/* returns 1 if children sum property holds ``for the given node and both of its children*/``int` `isSumProperty(``struct` `node* node)``{``    ``/* left_data is left child data and``       ``right_data is for right child data*/``    ``int` `left_data = 0, right_data = 0;``     ` `    ``/* If node is NULL or it's a leaf node ``    ``then return true */``    ``if``(node == NULL ||``        ``(node->left == NULL && ``         ``node->right == NULL))``        ``return` `1;``    ``else``    ``{``        ``/* If left child is not present then 0 ``        ``is used as data of left child */``        ``if``(node->left != NULL)``        ``left_data = node->left->data;``     ` `        ``/* If right child is not present then 0 ``        ``is used as data of right child */``        ``if``(node->right != NULL)``        ``right_data = node->right->data;``     ` `        ``/* if the node and both of its children ``        ``satisfy the property return 1 else 0*/``        ``if``((node->data == left_data + right_data)&&``            ``isSumProperty(node->left) &&``            ``isSumProperty(node->right))``        ``return` `1;``        ``else``        ``return` `0;``    ``}``}`` ` `/*``Helper function that allocates a new node``with the given data and NULL left and right``pointers.``*/``struct` `node* newNode(``int` `data)``{``    ``struct` `node* node =``        ``(``struct` `node*)``malloc``(``sizeof``(``struct` `node));``    ``node->data = data;``    ``node->left = NULL;``    ``node->right = NULL;``    ``return``(node);``}`` ` `// Driver Code``int` `main()``{``    ``struct` `node *root = newNode(10);``    ``root->left     = newNode(8);``    ``root->right = newNode(2);``    ``root->left->left = newNode(3);``    ``root->left->right = newNode(5);``    ``root->right->right = newNode(2);``    ``if``(isSumProperty(root))``        ``cout << ``"The given tree satisfies "``            ``<< ``"the children sum property "``;``    ``else``        ``cout << ``"The given tree does not satisfy "``            ``<< ``"the children sum property "``;`` ` `    ``getchar``();``    ``return` `0;``}``// This code is contributed by Akanksha Rai`

## C

 `/* Program to check children sum property */``#include ``#include `` ` `/* A binary tree node has data, left child and right child */``struct` `node``{``    ``int` `data;``    ``struct` `node* left;``    ``struct` `node* right;``};`` ` `/* returns 1 if children sum property holds for the given``    ``node and both of its children*/``int` `isSumProperty(``struct` `node* node)``{``  ``/* left_data is left child data and right_data is for right ``     ``child data*/``  ``int` `left_data = 0,  right_data = 0;`` ` `  ``/* If node is NULL or it's a leaf node then``     ``return true */``  ``if``(node == NULL ||``     ``(node->left == NULL && node->right == NULL))``    ``return` `1;``  ``else``  ``{``    ``/* If left child is not present then 0 is used``       ``as data of left child */``    ``if``(node->left != NULL)``      ``left_data = node->left->data;`` ` `    ``/* If right child is not present then 0 is used``      ``as data of right child */``    ``if``(node->right != NULL)``      ``right_data = node->right->data;`` ` `    ``/* if the node and both of its children satisfy the``       ``property return 1 else 0*/``    ``if``((node->data == left_data + right_data)&&``        ``isSumProperty(node->left) &&``        ``isSumProperty(node->right))``      ``return` `1;``    ``else``      ``return` `0;``  ``}``}`` ` `/*`` ``Helper function that allocates a new node`` ``with the given data and NULL left and right`` ``pointers.``*/``struct` `node* newNode(``int` `data)``{``  ``struct` `node* node =``      ``(``struct` `node*)``malloc``(``sizeof``(``struct` `node));``  ``node->data = data;``  ``node->left = NULL;``  ``node->right = NULL;``  ``return``(node);``}`` ` `/* Driver program to test above function */``int` `main()``{``  ``struct` `node *root  = newNode(10);``  ``root->left         = newNode(8);``  ``root->right        = newNode(2);``  ``root->left->left   = newNode(3);``  ``root->left->right  = newNode(5);``  ``root->right->right = newNode(2);``  ``if``(isSumProperty(root))``    ``printf``(``"The given tree satisfies the children sum property "``);``  ``else``    ``printf``(``"The given tree does not satisfy the children sum property "``);`` ` `  ``getchar``();``  ``return` `0;``}`

## Java

 `// Java program to check children sum property``  ` `/* A binary tree node has data, pointer to left child ``   ``and a pointer to right child */``class` `Node ``{``    ``int` `data;``    ``Node left, right;``  ` `    ``public` `Node(``int` `d) ``    ``{``        ``data = d;``        ``left = right = ``null``;``    ``}``}``  ` `class` `BinaryTree ``{``    ``Node root;``  ` `    ``/* returns 1 if children sum property holds for the given``    ``node and both of its children*/``    ``int` `isSumProperty(Node node) ``    ``{``          ` `        ``/* left_data is left child data and right_data is for right ``           ``child data*/``        ``int` `left_data = ``0``, right_data = ``0``;``  ` `        ``/* If node is NULL or it's a leaf node then``        ``return true */``        ``if` `(node == ``null``                ``|| (node.left == ``null` `&& node.right == ``null``))``            ``return` `1``;``        ``else``        ``{``             ` `            ``/* If left child is not present then 0 is used``               ``as data of left child */``            ``if` `(node.left != ``null``) ``                ``left_data = node.left.data;``  ` `            ``/* If right child is not present then 0 is used``               ``as data of right child */``            ``if` `(node.right != ``null``) ``                ``right_data = node.right.data;``  ` `            ``/* if the node and both of its children satisfy the``               ``property return 1 else 0*/``            ``if` `((node.data == left_data + right_data)``                    ``&& (isSumProperty(node.left)!=``0``)``                    ``&& isSumProperty(node.right)!=``0``)``                ``return` `1``;``            ``else``                ``return` `0``;``        ``}``    ``}``     ` `    ``/* driver program to test the above functions */``    ``public` `static` `void` `main(String[] args) ``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``10``);``        ``tree.root.left = ``new` `Node(``8``);``        ``tree.root.right = ``new` `Node(``2``);``        ``tree.root.left.left = ``new` `Node(``3``);``        ``tree.root.left.right = ``new` `Node(``5``);``        ``tree.root.right.right = ``new` `Node(``2``);``        ``if` `(tree.isSumProperty(tree.root) != ``0``)``            ``System.out.println(``"The given tree satisfies children"``                    ``+ ``" sum property"``);``        ``else``            ``System.out.println(``"The given tree does not satisfy children"``                    ``+ ``" sum property"``);``    ``}``}`

## Python3

 `# Python3 program to check children``# sum property `` ` `# Helper class that allocates a new ``# node with the given data and None ``# left and right pointers. ``class` `newNode:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data ``        ``self``.left ``=` `None``        ``self``.right ``=` `None`` ` `# returns 1 if children sum property ``# holds for the given node and both ``# of its children``def` `isSumProperty(node):``         ` `    ``# left_data is left child data and ``    ``# right_data is for right child data``    ``left_data ``=` `0``    ``right_data ``=` `0``     ` `    ``# If node is None or it's a leaf ``    ``# node then return true ``    ``if``(node ``=``=` `None` `or` `(node.left ``=``=` `None` `and` `                        ``node.right ``=``=` `None``)): ``        ``return` `1``    ``else``:``         ` `        ``# If left child is not present then ``        ``# 0 is used as data of left child ``        ``if``(node.left !``=` `None``):``            ``left_data ``=` `node.left.data ``     ` `        ``# If right child is not present then ``        ``# 0 is used as data of right child ``        ``if``(node.right !``=` `None``):``            ``right_data ``=` `node.right.data ``     ` `        ``# if the node and both of its children  ``        ``# satisfy the property return 1 else 0``        ``if``((node.data ``=``=` `left_data ``+` `right_data) ``and` `                        ``isSumProperty(node.left) ``and` `                        ``isSumProperty(node.right)):``            ``return` `1``        ``else``:``            ``return` `0`` ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``root ``=` `newNode(``10``) ``    ``root.left ``=` `newNode(``8``) ``    ``root.right ``=` `newNode(``2``) ``    ``root.left.left ``=` `newNode(``3``) ``    ``root.left.right ``=` `newNode(``5``) ``    ``root.right.right ``=` `newNode(``2``) ``    ``if``(isSumProperty(root)): ``        ``print``(``"The given tree satisfies the"``, ``                    ``"children sum property "``) ``    ``else``:``        ``print``(``"The given tree does not satisfy"``,``                   ``"the children sum property "``)``     ` `# This code is contributed by PranchalK`

## C#

 `// C# program to check children sum property ``using` `System;`` ` `/* A binary tree node has data, pointer ``to left child and a pointer to right child */``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right;`` ` `    ``public` `Node(``int` `d)``    ``{``        ``data = d;``        ``left = right = ``null``;``    ``}``}`` ` `class` `GFG``{``public` `Node root;`` ` `/* returns 1 if children sum property holds ``for the given node and both of its children*/``public` `virtual` `int` `isSumProperty(Node node)``{`` ` `    ``/* left_data is left child data and ``    ``right_data is for right child data*/``    ``int` `left_data = 0, right_data = 0;`` ` `    ``/* If node is NULL or it's a leaf ``    ``node then return true */``    ``if` `(node == ``null` `|| (node.left == ``null` `&& ``                         ``node.right == ``null``))``    ``{``        ``return` `1;``    ``}``    ``else``    ``{`` ` `        ``/* If left child is not present ``        ``then 0 is used as data of left child */``        ``if` `(node.left != ``null``)``        ``{``            ``left_data = node.left.data;``        ``}`` ` `        ``/* If right child is not present then ``        ``0 is used as data of right child */``        ``if` `(node.right != ``null``)``        ``{``            ``right_data = node.right.data;``        ``}`` ` `        ``/* if the node and both of its children ``        ``satisfy the property return 1 else 0*/``        ``if` `((node.data == left_data + right_data) && ``                  ``(isSumProperty(node.left) != 0) && ``                   ``isSumProperty(node.right) != 0)``        ``{``            ``return` `1;``        ``}``        ``else``        ``{``            ``return` `0;``        ``}``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``GFG tree = ``new` `GFG();``    ``tree.root = ``new` `Node(10);``    ``tree.root.left = ``new` `Node(8);``    ``tree.root.right = ``new` `Node(2);``    ``tree.root.left.left = ``new` `Node(3);``    ``tree.root.left.right = ``new` `Node(5);``    ``tree.root.right.right = ``new` `Node(2);``    ``if` `(tree.isSumProperty(tree.root) != 0)``    ``{``        ``Console.WriteLine(``"The given tree satisfies"` `+ ``                            ``" children sum property"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"The given tree does not"` `+ ``                   ``" satisfy children sum property"``);``    ``}``}``}`` ` `// This code is contributed by Shrikant13`

Output:
```The given tree satisfies the children sum property
```

Time Complexity: O(n), we are doing a complete traversal of the tree.

As an exercise, extend the above question for an n-ary tree.

This question was asked by Shekhar.

Please write comments if you find any bug in the above algorithm or a better way to solve the same problem.

My Personal Notes arrow_drop_up