GeeksforGeeks App
Open App
Browser
Continue

# Check if a given Binary Tree is SumTree

Write a function that returns true if the given Binary Tree is SumTree else false. A SumTree is a Binary Tree where the value of a node is equal to the sum of the nodes present in its left subtree and right subtree. An empty tree is SumTree and the sum of an empty tree can be considered as 0. A leaf node is also considered as SumTree.

Following is an example of SumTree.

```          26
/   \
10     3
/    \     \
4      6      3```
Recommended Practice

Method 1 (Simple)
Get the sum of nodes in the left subtree and right subtree. Check if the sum calculated is equal to the root’s data. Also, recursively check if the left and right subtrees are SumTrees.

## C++

 `// C++ program to check if Binary tree``// is sum tree or not``#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;``};` `// A utility function to get the sum``// of values in tree with root as root``int` `sum(``struct` `node *root)``{``    ``if` `(root == NULL)``        ``return` `0;``    ` `    ``return` `sum(root->left) + root->data +``           ``sum(root->right);``}` `// Returns 1 if sum property holds for``// the given node and both of its children``int` `isSumTree(``struct` `node* node)``{``    ``int` `ls, rs;` `    ``// If node is NULL or it's a leaf``    ``// node then return true``    ``if` `(node == NULL ||``       ``(node->left == NULL &&``        ``node->right == NULL))``        ``return` `1;` `   ``// Get sum of nodes in left and``   ``// right subtrees``   ``ls = sum(node->left);``   ``rs = sum(node->right);` `   ``// If the node and both of its``   ``// children satisfy the property``   ``// return 1 else 0``    ``if` `((node->data == ls + rs) &&``          ``isSumTree(node->left) &&``          ``isSumTree(node->right))``        ``return` `1;` `   ``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(26);``    ``root->left = newNode(10);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(6);``    ``root->right->right = newNode(3);``    ` `    ``if` `(isSumTree(root))``        ``cout << ``"The given tree is a SumTree "``;``    ``else``        ``cout << ``"The given tree is not a SumTree "``;` `    ``getchar``();``    ``return` `0;``}` `// This code is contributed by khushboogoyal499`

## C

 `// C program to check if Binary tree``// is sum tree or not``#include ``#include ` `/* A binary tree node has data, left child and right child */``struct` `node``{``    ``int` `data;``    ``struct` `node* left;``    ``struct` `node* right;``};` `/* A utility function to get the sum of values in tree with root``  ``as root */``int` `sum(``struct` `node *root)``{``   ``if``(root == NULL)``     ``return` `0;``   ``return` `sum(root->left) + root->data + sum(root->right);``}` `/* returns 1 if sum property holds for the given``    ``node and both of its children */``int` `isSumTree(``struct` `node* node)``{``    ``int` `ls, rs;` `    ``/* If node is NULL or it's a leaf node then``       ``return true */``    ``if``(node == NULL ||``            ``(node->left == NULL && node->right == NULL))``        ``return` `1;` `   ``/* Get sum of nodes in left and right subtrees */``   ``ls = sum(node->left);``   ``rs = sum(node->right);` `   ``/* if the node and both of its children satisfy the``       ``property return 1 else 0*/``    ``if``((node->data == ls + rs)&&``            ``isSumTree(node->left) &&``            ``isSumTree(node->right))``        ``return` `1;` `   ``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(26);``    ``root->left         = newNode(10);``    ``root->right        = newNode(3);``    ``root->left->left   = newNode(4);``    ``root->left->right  = newNode(6);``    ``root->right->right = newNode(3);``    ``if``(isSumTree(root))``        ``printf``(``"The given tree is a SumTree."``);``    ``else``        ``printf``(``"The given tree is not a SumTree."``);` `    ``getchar``();``    ``return` `0;``}`

## Java

 `// Java program to check if Binary tree``// is sum tree or not``import` `java.io.*;` `// A binary tree node has data,``// left child and right child``class` `Node``{``    ``int` `data;``    ``Node left, right, nextRight;``  ` `    ``// Helper function that allocates a new node``    ``// with the given data and NULL left and right``    ``// pointers.``    ``Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}``class` `BinaryTree {``    ``public` `static` `Node root;``  ` `    ``// A utility function to get the sum``    ``// of values in tree with root as root``    ``static` `int` `sum(Node node)``    ``{``        ``if``(node == ``null``)``        ``{``            ``return` `0``;``        ``}``        ``return` `(sum(node.left) + node.data+sum(node.right));``    ``}``  ` `    ``// Returns 1 if sum property holds for``    ``// the given node and both of its children``    ``static` `int` `isSumTree(Node node)``    ``{``        ``int` `ls,rs;``      ` `        ``// If node is NULL or it's a leaf``        ``// node then return true``        ``if``(node == ``null` `|| (node.left == ``null` `&& node.right == ``null``))``        ``{``            ``return` `1``;``        ``}``      ` `        ``// Get sum of nodes in left and``        ``// right subtrees``        ``ls = sum(node.left);``        ``rs = sum(node.right);``      ` `        ``// If the node and both of its``        ``// children satisfy the property``        ``// return 1 else 0``        ``if``((node.data == ls + rs) && isSumTree(node.left) != ``0` `&& isSumTree(node.right) != ``0``)``        ``{``            ``return` `1``;``        ``}``        ``return` `0``;``    ``}``  ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``BinaryTree tree=``new` `BinaryTree();``        ``tree.root=``new` `Node(``26``);``        ``tree.root.left=``new` `Node(``10``);``        ``tree.root.right=``new` `Node(``3``);``        ``tree.root.left.left=``new` `Node(``4``);``        ``tree.root.left.right=``new` `Node(``6``);``        ``tree.root.right.right=``new` `Node(``3``);``        ``if``(isSumTree(root) != ``0``)``        ``{``            ``System.out.println(``"The given tree is a SumTree"``);``        ``}``        ``else``        ``{``            ``System.out.println(``"The given tree is not a SumTree"``);``        ``}``    ``}``}` `// This code is contributed by rag2127`

## Python3

 `# Python3 program to implement``# the above approach` `# A binary tree node has data,``# left child and right child``class` `node:``  ` `    ``def` `__init__(``self``, x):``      ` `        ``self``.data ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# A utility function to get the sum``# of values in tree with root as root``def` `sum``(root):``  ` `    ``if``(root ``=``=` `None``):``        ``return` `0``    ``return` `(``sum``(root.left) ``+``            ``root.data ``+``            ``sum``(root.right))` `# returns 1 if sum property holds``# for the given node and both of``# its children``def` `isSumTree(node):``  ` `    ``# ls, rs` `    ``# 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` `    ``# Get sum of nodes in left and``    ``# right subtrees``    ``ls ``=` `sum``(node.left)``    ``rs ``=` `sum``(node.right)` `    ``# if the node and both of its children``    ``# satisfy the property return 1 else 0``    ``if``((node.data ``=``=` `ls ``+` `rs) ``and``        ``isSumTree(node.left) ``and``        ``isSumTree(node.right)):``        ``return` `1` `    ``return` `0` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``root ``=` `node(``26``)``    ``root.left``=` `node(``10``)``    ``root.right ``=` `node(``3``)``    ``root.left.left ``=` `node(``4``)``    ``root.left.right ``=` `node(``6``)``    ``root.right.right ``=` `node(``3``)``    ` `    ``if``(isSumTree(root)):``        ``print``(``"The given tree is a SumTree "``)``    ``else``:``        ``print``(``"The given tree is not a SumTree "``)` `# This code is contributed by Mohit Kumar 29`

## C#

 `// C# program to check if Binary tree``// is sum tree or not``using` `System;`` ` `// A binary tree node has data,``// left child and right child``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right, nextRight;``   ` `    ``// Helper function that allocates a new node``    ``// with the given data and NULL left and right``    ``// pointers.``    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `class` `BinaryTree {``    ` `    ``public` `Node root;``   ` `    ``// A utility function to get the sum``    ``// of values in tree with root as root``    ``int` `sum(Node node)``    ``{``        ``if``(node == ``null``)``        ``{``            ``return` `0;``        ``}``        ``return` `(sum(node.left) + node.data+sum(node.right));``    ``}``   ` `    ``// Returns 1 if sum property holds for``    ``// the given node and both of its children``    ``int` `isSumTree(Node node)``    ``{``        ``int` `ls,rs;``       ` `        ``// If node is NULL or it's a leaf``        ``// node then return true``        ``if``(node == ``null` `|| (node.left == ``null` `&& node.right == ``null``))``        ``{``            ``return` `1;``        ``}``       ` `        ``// Get sum of nodes in left and``        ``// right subtrees``        ``ls = sum(node.left);``        ``rs = sum(node.right);``       ` `        ``// If the node and both of its``        ``// children satisfy the property``        ``// return 1 else 0``        ``if``((node.data == ls + rs) && isSumTree(node.left) != 0 && isSumTree(node.right) != 0)``        ``{``            ``return` `1;``        ``}``        ``return` `0;``    ``}``   ` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(26);``        ``tree.root.left = ``new` `Node(10);``        ``tree.root.right = ``new` `Node(3);``        ``tree.root.left.left = ``new` `Node(4);``        ``tree.root.left.right = ``new` `Node(6);``        ``tree.root.right.right = ``new` `Node(3);``        ``if``(tree.isSumTree(tree.root) != 0)``        ``{``            ``Console.WriteLine(``"The given tree is a SumTree"``);``        ``}``        ``else``        ``{``            ``Console.WriteLine(``"The given tree is not a SumTree"``);``        ``}``    ``}``}`` ` `// This code is contributed by Pratham76`

## Javascript

 ``

Output

`The given tree is a SumTree`

Time Complexity: O(n2) in the worst case. The worst-case occurs for a skewed tree.

Auxiliary Space: O(n) for stack space

Method 2 (Tricky)
Method 1 uses sum() to get the sum of nodes in left and right subtrees. Method 2 uses the following rules to get the sum directly.
1) If the node is a leaf node then the sum of the subtree rooted with this node is equal to the value of this node.
2) If the node is not a leaf node then the sum of the subtree rooted with this node is twice the value of this node (Assuming that the tree rooted with this node is SumTree).

## C++

 `// C++ program to check if Binary tree``// is sum tree or not``#include``using` `namespace` `std;` `/* A binary tree node has data,``   ``left child and right child */``struct` `node``{``    ``int` `data;``    ``node* left;``    ``node* right;``};` `/* Utility function to check if``the given node is leaf or not */``int` `isLeaf(node *node)``{``    ``if``(node == NULL)``        ``return` `0;``    ``if``(node->left == NULL && node->right == NULL)``        ``return` `1;``    ``return` `0;``}` `/* returns 1 if SumTree property holds for the given``    ``tree */``int` `isSumTree(node* node)``{``    ``int` `ls; ``// for sum of nodes in left subtree``    ``int` `rs; ``// for sum of nodes in right subtree` `    ``/* If node is NULL or it's a leaf node then``       ``return true */``    ``if``(node == NULL || isLeaf(node))``        ``return` `1;` `    ``if``( isSumTree(node->left) && isSumTree(node->right))``    ``{``      ` `        ``// Get the sum of nodes in left subtree``        ``if``(node->left == NULL)``            ``ls = 0;``        ``else` `if``(isLeaf(node->left))``            ``ls = node->left->data;``        ``else``            ``ls = 2 * (node->left->data);` `        ``// Get the sum of nodes in right subtree``        ``if``(node->right == NULL)``            ``rs = 0;``        ``else` `if``(isLeaf(node->right))``            ``rs = node->right->data;``        ``else``            ``rs = 2 * (node->right->data);` `        ``/* If root's data is equal to sum of nodes in left``           ``and right subtrees then return 1 else return 0*/``        ``return``(node->data == ls + rs);``    ``}``    ``return` `0;``}` `/* Helper function that allocates a new node`` ``with the given data and NULL left and right`` ``pointers.``*/``node* newNode(``int` `data)``{``    ``node* node1 = ``new` `node();``    ``node1->data = data;``    ``node1->left = NULL;``    ``node1->right = NULL;``    ``return``(node1);``}` `/* Driver code */``int` `main()``{``    ``node *root  = newNode(26);``    ``root->left = newNode(10);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(6);``    ``root->right->right = newNode(3);``    ``if``(isSumTree(root))``        ``cout << ``"The given tree is a SumTree "``;``    ``else``        ``cout << ``"The given tree is not a SumTree "``;``    ``return` `0;``}` `// This code is contributed by rutvik_56`

## C

 `// C program to check if Binary tree``// is sum tree or not``#include ``#include ` `/* A binary tree node has data,``   ``left child and right child */``struct` `node``{``    ``int` `data;``    ``struct` `node* left;``    ``struct` `node* right;``};` `/* Utility function to check if the given node is leaf or not */``int` `isLeaf(``struct` `node *node)``{``    ``if``(node == NULL)``        ``return` `0;``    ``if``(node->left == NULL && node->right == NULL)``        ``return` `1;``    ``return` `0;``}` `/* returns 1 if SumTree property holds for the given``    ``tree */``int` `isSumTree(``struct` `node* node)``{``    ``int` `ls; ``// for sum of nodes in left subtree``    ``int` `rs; ``// for sum of nodes in right subtree` `    ``/* If node is NULL or it's a leaf node then``       ``return true */``    ``if``(node == NULL || isLeaf(node))``        ``return` `1;` `    ``if``( isSumTree(node->left) && isSumTree(node->right))``    ``{``        ``// Get the sum of nodes in left subtree``        ``if``(node->left == NULL)``            ``ls = 0;``        ``else` `if``(isLeaf(node->left))``            ``ls = node->left->data;``        ``else``            ``ls = 2*(node->left->data);` `        ``// Get the sum of nodes in right subtree``        ``if``(node->right == NULL)``            ``rs = 0;``        ``else` `if``(isLeaf(node->right))``            ``rs = node->right->data;``        ``else``            ``rs = 2*(node->right->data);` `        ``/* If root's data is equal to sum of nodes in left``           ``and right subtrees then return 1 else return 0*/``        ``return``(node->data == ls + rs);``    ``}` `    ``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(26);``    ``root->left         = newNode(10);``    ``root->right        = newNode(3);``    ``root->left->left   = newNode(4);``    ``root->left->right  = newNode(6);``    ``root->right->right = newNode(3);``    ``if``(isSumTree(root))``        ``printf``(``"The given tree is a SumTree "``);``    ``else``        ``printf``(``"The given tree is not a SumTree "``);` `    ``getchar``();``    ``return` `0;``}`

## Java

 `// Java program to check if Binary tree is sum tree or not`` `  `/* A binary tree node has data, left child and right child */``class` `Node``{``    ``int` `data;``    ``Node left, right, nextRight;`` ` `    ``Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = nextRight = ``null``;``    ``}``}`` ` `class` `BinaryTree``{``    ``Node root;`` ` `    ``/* Utility function to check if the given node is leaf or not */``    ``int` `isLeaf(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return` `0``;``        ``if` `(node.left == ``null` `&& node.right == ``null``)``            ``return` `1``;``        ``return` `0``;``    ``}`` ` `    ``/* returns 1 if SumTree property holds for the given``       ``tree */``    ``int` `isSumTree(Node node)``    ``{``        ``int` `ls; ``// for sum of nodes in left subtree``        ``int` `rs; ``// for sum of nodes in right subtree`` ` `        ``/* If node is NULL or it's a leaf node then``         ``return true */``        ``if` `(node == ``null` `|| isLeaf(node) == ``1``)``            ``return` `1``;`` ` `        ``if` `(isSumTree(node.left) != ``0` `&& isSumTree(node.right) != ``0``)``        ``{``            ``// Get the sum of nodes in left subtree``            ``if` `(node.left == ``null``)``                ``ls = ``0``;``            ``else` `if` `(isLeaf(node.left) != ``0``)``                ``ls = node.left.data;``            ``else``                ``ls = ``2` `* (node.left.data);`` ` `            ``// Get the sum of nodes in right subtree``            ``if` `(node.right == ``null``)``                ``rs = ``0``;``            ``else` `if` `(isLeaf(node.right) != ``0``)``                ``rs = node.right.data;``            ``else``                ``rs = ``2` `* (node.right.data);``             ` `            ``/* If root's data is equal to sum of nodes in left``               ``and right subtrees then return 1 else return 0*/``            ``if` `((node.data == rs + ls))``                ``return` `1``;``            ``else``                ``return` `0``;``        ``}`` ` `        ``return` `0``;``    ``}`` ` `    ``/* Driver program to test above functions */``    ``public` `static` `void` `main(String args[])``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``tree.root = ``new` `Node(``26``);``        ``tree.root.left = ``new` `Node(``10``);``        ``tree.root.right = ``new` `Node(``3``);``        ``tree.root.left.left = ``new` `Node(``4``);``        ``tree.root.left.right = ``new` `Node(``6``);``        ``tree.root.right.right = ``new` `Node(``3``);`` ` `        ``if` `(tree.isSumTree(tree.root) != ``0``)``            ``System.out.println(``"The given tree is a SumTree"``);``        ``else``            ``System.out.println(``"The given tree is not a SumTree"``);``    ``}``}` `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python3 program to check if``# Binary tree is sum tree or not` `# A binary tree node has data,``# left child and right child``class` `node:` `    ``def` `__init__(``self``, x):` `        ``self``.data ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None`  `def` `isLeaf(node):` `    ``if``(node ``=``=` `None``):``        ``return` `0``    ``if``(node.left ``=``=` `None` `and` `node.right ``=``=` `None``):``        ``return` `1``    ``return` `0` `# A utility function to get the sum``# of values in tree with root as root``def` `sum``(root):` `    ``if``(root ``=``=` `None``):``        ``return` `0``    ``return` `(``sum``(root.left) ``+``            ``root.data ``+``            ``sum``(root.right))`  `# returns 1 if SumTree property holds``# for the given tree``def` `isSumTree(node):``  ` `    ``# If node is None or``    ``# it's a leaf node then return true``    ``if``(node ``=``=` `None` `or` `isLeaf(node)):``        ``return` `1` `    ``if``(isSumTree(node.left) ``and` `isSumTree(node.right)):``      ` `        ``# Get the sum of nodes in left subtree``        ``if``(node.left ``=``=` `None``):``            ``ls ``=` `0``        ``elif``(isLeaf(node.left)):``            ``ls ``=` `node.left.data``        ``else``:``            ``ls ``=` `2` `*` `(node.left.data)` `        ``# Get the sum of nodes in right subtree``        ``if``(node.right ``=``=` `None``):``            ``rs ``=` `0``        ``elif``(isLeaf(node.right)):``            ``rs ``=` `node.right.data``        ``else``:``            ``rs ``=` `2` `*` `(node.right.data)` `        ``# If root's data is equal to sum of nodes``        ``# in left and right subtrees then return 1``        ``# else return 0``        ``return``(node.data ``=``=` `ls ``+` `rs)` `    ``return` `0` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``root ``=` `node(``26``)``    ``root.left ``=` `node(``10``)``    ``root.right ``=` `node(``3``)``    ``root.left.left ``=` `node(``4``)``    ``root.left.right ``=` `node(``6``)``    ``root.right.right ``=` `node(``3``)` `    ``if``(isSumTree(root)):``        ``print``(``"The given tree is a SumTree "``)``    ``else``:``        ``print``(``"The given tree is not a SumTree "``)` `# This code is contributed by kirtishsurangalikar`

## C#

 `// C# program to check if Binary tree``// is sum tree or not``using` `System;` `// A binary tree node has data, left``// child and right child``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left, right, nextRight;`` ` `    ``public` `Node(``int` `d)``    ``{``        ``data = d;``        ``left = right = nextRight = ``null``;``    ``}``}` `public` `class` `BinaryTree{``    ` `public` `static` `Node root;` `// Utility function to check if``// the given node is leaf or not``public` `int` `isLeaf(Node node)``{``    ``if` `(node == ``null``)``        ``return` `0;``        ` `    ``if` `(node.left == ``null` `&&``        ``node.right == ``null``)``        ``return` `1;``        ` `    ``return` `0;``}` `// Returns 1 if SumTree property holds``// for the given tree``public` `int` `isSumTree(Node node)``{``    ` `    ``// For sum of nodes in left subtree``    ``int` `ls;``    ` `    ``// For sum of nodes in right subtree``    ``int` `rs;` `    ``// If node is NULL or it's a leaf``    ``// node then return true``    ``if` `(node == ``null` `|| isLeaf(node) == 1)``        ``return` `1;` `    ``if` `(isSumTree(node.left) != 0 &&``       ``isSumTree(node.right) != 0)``    ``{``        ` `        ``// Get the sum of nodes in left subtree``        ``if` `(node.left == ``null``)``            ``ls = 0;``        ``else` `if` `(isLeaf(node.left) != 0)``            ``ls = node.left.data;``        ``else``            ``ls = 2 * (node.left.data);` `        ``// Get the sum of nodes in right subtree``        ``if` `(node.right == ``null``)``            ``rs = 0;``        ``else` `if` `(isLeaf(node.right) != 0)``            ``rs = node.right.data;``        ``else``            ``rs = 2 * (node.right.data);``          ` `        ``// If root's data is equal to sum of``        ``// nodes in left and right subtrees``        ``// then return 1 else return 0``        ``if` `((node.data == rs + ls))``            ``return` `1;``        ``else``            ``return` `0;``    ``}` `    ``return` `0;``}` `// Driver code``static` `public` `void` `Main()``{``    ``BinaryTree tree = ``new` `BinaryTree();``    ``BinaryTree.root = ``new` `Node(26);``    ``BinaryTree.root.left = ``new` `Node(10);``    ``BinaryTree.root.right = ``new` `Node(3);``    ``BinaryTree.root.left.left = ``new` `Node(4);``    ``BinaryTree.root.left.right = ``new` `Node(6);``    ``BinaryTree.root.right.right = ``new` `Node(3);``    ` `    ``if` `(tree.isSumTree(BinaryTree.root) != 0)``    ``{``        ``Console.WriteLine(``"The given tree is a SumTree"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"The given tree is "` `+``                          ``"not a SumTree"``);``    ``}``}``}` `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``

Output:

`The given tree is a SumTree`

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

Method 3

1. Similar to postorder traversal iteratively find the sum in each step
2. Return left + right + current data if left + right is equal to current node data
3. Else return -1

## C++

 `// C++ program to check if Binary tree``// is sum tree or not``#include``using` `namespace` `std;` `/* A binary tree node has data,``left child and right child */``struct` `node``{``    ``int` `data;``    ``node* left;``    ``node* right;``};` `/* Utility function to check if``the given node is leaf or not */``int` `isLeaf(node *node)``{``    ``if``(node == NULL)``        ``return` `0;``    ``if``(node->left == NULL && node->right == NULL)``        ``return` `1;``    ``return` `0;``}` `/* returns data if SumTree property holds for the given``    ``tree else return -1*/``int` `isSumTree(node* node)``{``    ``if``(node == NULL)``    ``return` `0;``    ` `    ``int` `ls; ``// for sum of nodes in left subtree``    ``int` `rs; ``// for sum of nodes in right subtree``    ` `    ` `    ``ls = isSumTree(node->left);``    ``if``(ls == -1)            ``// To stop for further traversal of tree if found not sumTree``    ``return` `-1;``    ` `    ``rs = isSumTree(node->right);``    ``if``(rs == -1)            ``// To stop for further traversal of tree if found not sumTree``    ``return` `-1;``    ` `    ` `    ``if``(isLeaf(node) || ls + rs == node->data)``    ``return` `ls + rs + node->data;``    ``else``    ``return` `-1;`` ` `}` `/* Helper function that allocates a new node``with the given data and NULL left and right``pointers.``*/``node* newNode(``int` `data)``{``    ``node* node1 = ``new` `node();``    ``node1->data = data;``    ``node1->left = NULL;``    ``node1->right = NULL;``    ``return``(node1);``}` `/* Driver code */``int` `main()``{``    ``node *root = newNode(26);``    ``root->left = newNode(10);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(6);``    ``root->right->right = newNode(3);``    ` `    ``int` `total = isSumTree(root);``    ``if``(total != -1 && total == 2*(root->data))``    ``cout<<``"Tree is a Sum Tree"``;``    ``else``    ``cout<<``"Given Tree is not sum Tree"``;``    ` `    ``return` `0;``}` `// This code is contributed by Mugunthan`

## C++14

 `// C++ program to check if Binary tree``// is sum tree or not``#include``using` `namespace` `std;` `/* A binary tree node has data,``left child and right child */``struct` `node``{``    ``int` `data;``    ``node* left;``    ``node* right;``};` `/* Utility function to check if``the given node is leaf or not */``int` `isLeaf(node *node)``{``    ``if``(node == NULL)``        ``return` `0;``    ``if``(node->left == NULL && node->right == NULL)``        ``return` `1;``    ``return` `0;``}` `/* returns data if SumTree property holds for the given``    ``tree else return -1*/``int` `isSumTree(node* node)``{``    ``if``(node == NULL)``    ``return` `0;``    ` `    ``int` `ls; ``// for sum of nodes in left subtree``    ``int` `rs; ``// for sum of nodes in right subtree``    ` `    ` `    ``ls = isSumTree(node->left);``    ``if``(ls == -1)            ``// To stop for further traversal of tree if found not sumTree``    ``return` `-1;``    ` `    ``rs = isSumTree(node->right);``    ``if``(rs == -1)            ``// To stop for further traversal of tree if found not sumTree``    ``return` `-1;``    ` `    ` `    ``if``(isLeaf(node) || ls + rs == node->data)``    ``return` `ls + rs + node->data;``    ``else``    ``return` `-1;`` ` `}` `/* Helper function that allocates a new node``with the given data and NULL left and right``pointers.``*/``node* newNode(``int` `data)``{``    ``node* node1 = ``new` `node();``    ``node1->data = data;``    ``node1->left = NULL;``    ``node1->right = NULL;``    ``return``(node1);``}` `/* Driver code */``int` `main()``{``    ``node *root = newNode(26);``    ``root->left = newNode(10);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(6);``    ``root->right->right = newNode(3);``    ` `    ``int` `total = isSumTree(root);``    ``if``(total != -1 && total == 2*(root->data))``    ``cout<<``"Sum Tree"``;``    ``else``    ``cout<<``"No sum Tree"``;``    ` `    ``return` `0;``}` `// This code is contributed by Mugunthan`

## Java

 `// Java program to check if Binary tree``// is sum tree or not` `import` `java.util.*;` `class` `GFG``{``/* A binary tree node has data,``left child and right child */` `static` `class` `Node {``int` `data;``Node left, right;` `}` `/* Utility function to check if``the given node is leaf or not */``static` `int` `isLeaf(Node node)``{``    ``if``(node == ``null``)``        ``return` `0``;``    ``if``(node.left == ``null` `&& node.right == ``null``)``        ``return` `1``;``    ``return` `0``;``}` `/* returns data if SumTree property holds for the given``    ``tree else return -1*/``static` `int` `isSumTree(Node node)``{``    ``if``(node == ``null``)``    ``return` `0``;``    ` `    ``int` `ls; ``// for sum of nodes in left subtree``    ``int` `rs; ``// for sum of nodes in right subtree``    ` `    ` `    ``ls = isSumTree(node.left);``    ``if``(ls == -``1``)            ``// To stop for further traversal of tree if found not sumTree``    ``return` `-``1``;``    ` `    ``rs = isSumTree(node.right);``    ``if``(rs == -``1``)            ``// To stop for further traversal of tree if found not sumTree``    ``return` `-``1``;``    ` `    ` `    ``if``(isLeaf(node)==``1` `|| ls + rs == node.data)``    ``return` `ls + rs + node.data;``    ``else``    ``return` `-``1``;`` ` `}` `/* Helper function that allocates a new node``with the given data and null left and right``pointers.``*/``static` `Node newNode(``int` `data)``{``    ``Node node1 = ``new` `Node();``    ``node1.data = data;``    ``node1.left = ``null``;``    ``node1.right = ``null``;``    ``return``(node1);``}` `public` `static` `void` `main(String args[])``{``    ``Node root = newNode(``26``);``    ``root.left = newNode(``10``);``    ``root.right = newNode(``3``);``    ``root.left.left = newNode(``4``);``    ``root.left.right = newNode(``6``);``    ``root.right.right = newNode(``3``);``    ` `    ``int` `total = isSumTree(root);``    ``if``(total != -``1` `&& total == ``2``*(root.data))``    ``System.out.print(``"Tree is a Sum Tree"``);``    ``else``     ``System.out.print(``"Given Tree is not sum Tree"``);``}``}` `// This code is contributed by jana_sayantan.`

## Python3

 `# Python3 program to check if``# Binary tree is sum tree or not`` ` `# A binary tree node has data,``# left child and right child``class` `node:`` ` `    ``def` `__init__(``self``, x):`` ` `        ``self``.data ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None`` ` ` ` `def` `isLeaf(node):`` ` `    ``if``(node ``=``=` `None``):``        ``return` `0``    ``if``(node.left ``=``=` `None` `and` `node.right ``=``=` `None``):``        ``return` `1``    ``return` `0`` `  `# returns data if SumTree property holds for the given``#    tree else return -1``def` `isSumTree(node):``    ``if``(node ``=``=` `None``):``        ``return` `0``    ` `    ``ls ``=` `isSumTree(node.left)``    ``if``(ls ``=``=` `-``1``):            ``#To stop for further traversal of tree if found not sumTree``        ``return` `-``1``        ` `    ``rs ``=` `isSumTree(node.right)``    ``if``(rs ``=``=` `-``1``):            ``#To stop for further traversal of tree if found not sumTree``        ``return` `-``1``    ` `    ` `    ``if``(isLeaf(node) ``or` `ls ``+` `rs ``=``=` `node.data):``        ``return` `ls ``+` `rs ``+` `node.data``    ``else``:``        ``return` `-``1`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:`` ` `    ``root ``=` `node(``26``)``    ``root.left ``=` `node(``10``)``    ``root.right ``=` `node(``3``)``    ``root.left.left ``=` `node(``4``)``    ``root.left.right ``=` `node(``6``)``    ``root.right.right ``=` `node(``3``)`` ` `    ``if``(isSumTree(root)):``        ``print``(``"The given tree is a SumTree "``)``    ``else``:``        ``print``(``"The given tree is not a SumTree "``)`` ` `# This code is contributed by Mugunthan`

## C#

 `// C# program to check if Binary tree``// is sum tree or not``using` `System;` `class` `Program {``    ``/* A binary tree node has data,``    ``left child and right child */``    ``public` `class` `Node {``        ``public` `int` `data;``        ``public` `Node left, right;``    ``}` `    ``/* Utility function to check if``    ``the given node is leaf or not */``    ``static` `int` `isLeaf(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return` `0;``        ``if` `(node.left == ``null` `&& node.right == ``null``)``            ``return` `1;``        ``return` `0;``    ``}` `    ``/* returns data if SumTree property holds for the given``    ``tree else return -1*/``    ``static` `int` `isSumTree(Node node)``    ``{``        ``if` `(node == ``null``)``            ``return` `0;` `        ``int` `ls; ``// for sum of nodes in left subtree``        ``int` `rs; ``// for sum of nodes in right subtree` `        ``ls = isSumTree(node.left);``        ``if` `(ls == -1) ``// To stop for further traversal of``                      ``// tree if found not sumTree``            ``return` `-1;` `        ``rs = isSumTree(node.right);``        ``if` `(rs == -1) ``// To stop for further traversal of``                      ``// tree if found not sumTree``            ``return` `-1;` `        ``if` `(isLeaf(node) == 1 || ls + rs == node.data)``            ``return` `ls + rs + node.data;``        ``else``            ``return` `-1;``    ``}` `    ``/* Helper function that allocates a new node``    ``with the given data and NULL left and right``    ``pointers.``    ``*/``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node node1 = ``new` `Node();``        ``node1.data = data;``        ``node1.left = ``null``;``        ``node1.right = ``null``;``        ``return` `(node1);``    ``}``    ``/* Driver code */``    ``static` `void` `Main(``string``[] args)``    ``{``        ``Node root = newNode(26);``        ``root.left = newNode(10);``        ``root.right = newNode(3);``        ``root.left.left = newNode(4);``        ``root.left.right = newNode(6);``        ``root.right.right = newNode(3);``        ``int` `total = isSumTree(root);``        ``if` `(total != -1 && total == 2 * (root.data))``            ``Console.WriteLine(``"Tree is a Sum Tree"``);``        ``else``            ``Console.WriteLine(``"Given Tree is not sum Tree"``);``    ``}``}` `// This code is contributed by Tapesh(tapeshdua420)`

## Javascript

 ``

Time Complexity: O(n), since each element is traversed only once
Auxiliary Space: O(n), due to recursive stack space

Method 4: Iterative level-order traversal:

Sum Tree Property are;

1.Left subtree should be sumtree.
2. right subtree should be sumtree.
3. Sum of left subtree and right subtree should be equal to the root->data.

Follow the steps to implement the above idea.

1. Create an empty queue and add the root node to it.
2. While the queue is not empty:
a. Remove the front node from the queue.
b. If the node is a leaf node, continue.
c. If the sum of the left and right subtrees of the node is not equal to the value of the node, return false.
d. Add the left and right children of the node to the queue.
3. If all nodes satisfy the sum tree property, return true.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the above approach``#include ``#include ``using` `namespace` `std;` `// Definition for a binary tree node.``struct` `TreeNode {``    ``int` `val;``    ``TreeNode* left;``    ``TreeNode* right;``    ``TreeNode(``int` `x)``        ``: val(x)``        ``, left(NULL)``        ``, right(NULL)``    ``{``    ``}``};``// function to check if given binary tree is sumtree or not``bool` `isSumTree(TreeNode* root)``{``    ``// If root is NULL or it's a leaf node, return true``    ``if` `(root == NULL``        ``|| (root->left == NULL && root->right == NULL)) {``        ``return` `true``;``    ``}` `    ``// Create an empty queue and add the root node to it``    ``queue q;``    ``q.push(root);` `    ``while` `(!q.empty()) {``        ``// Remove the front node from the queue``        ``TreeNode* curr = q.front();``        ``q.pop();` `        ``// If the node is a leaf node, continue``        ``if` `(curr->left == NULL && curr->right == NULL) {``            ``continue``;``        ``}` `        ``// Calculate the sum of the left and right subtrees``        ``int` `sum = 0;``        ``if` `(curr->left != NULL) {``            ``sum += curr->left->val;``            ``q.push(curr->left);``        ``}``        ``if` `(curr->right != NULL) {``            ``sum += curr->right->val;``            ``q.push(curr->right);``        ``}` `        ``// If the sum of the left and right subtrees is not``        ``// equal to the value of the node, return false``        ``if` `(sum != curr->val) {``            ``return` `false``;``        ``}``    ``}` `    ``// If all nodes satisfy the sum tree property, return``    ``// true``    ``return` `true``;``}``// Driver Code``int` `main()``{``    ``// Example usage``    ``TreeNode* root = ``new` `TreeNode(26);``    ``root->left = ``new` `TreeNode(10);``    ``root->right = ``new` `TreeNode(3);``    ``root->left->left = ``new` `TreeNode(4);``    ``root->left->right = ``new` `TreeNode(6);``    ``root->right->right = ``new` `TreeNode(3);` `    ``if` `(isSumTree(root)) {``        ``cout << ``"Given binary tree is a sum tree."` `<< endl;``    ``}``    ``else` `{``        ``cout << ``"Given binary tree is not a sum tree."``             ``<< endl;``    ``}` `    ``return` `0;``}``// This code is contributed by Veerendra_Singh_Rajpoot`

## Java

 `// Java code addition` `import` `java.io.*;``import` `java.util.LinkedList;``import` `java.util.Queue;` `// Definition for a binary tree node.``class` `TreeNode {``    ``int` `val;``    ``TreeNode left, right;` `    ``TreeNode(``int` `data)``    ``{``        ``this``.val = data;``        ``left = ``null``;``        ``right = ``null``;``    ``}``}` `public` `class` `Main {``    ``// function to check if given binary tree is sumtree or``    ``// not``    ``public` `static` `boolean` `isSumTree(TreeNode root)``    ``{``        ``// If root is NULL or it's a leaf node, return true``        ``if` `(root == ``null``            ``|| (root.left == ``null` `&& root.right == ``null``)) {``            ``return` `true``;``        ``}` `        ``// Create an empty queue and add the root node to it``        ``Queue q = ``new` `LinkedList<>();``        ``q.add(root);` `        ``while` `(!q.isEmpty()) {``            ``// Remove the front node from the queue``            ``TreeNode curr = q.poll();` `            ``// If the node is a leaf node, continue``            ``if` `(curr.left == ``null` `&& curr.right == ``null``) {``                ``continue``;``            ``}` `            ``// Calculate the sum of the left and right``            ``// subtrees``            ``int` `sum = ``0``;``            ``if` `(curr.left != ``null``) {``                ``sum += curr.left.val;``                ``q.add(curr.left);``            ``}``            ``if` `(curr.right != ``null``) {``                ``sum += curr.right.val;``                ``q.add(curr.right);``            ``}` `            ``// If the sum of the left and right subtrees is``            ``// not equal to the value of the node, return``            ``// false``            ``if` `(sum != curr.val) {``                ``return` `false``;``            ``}``        ``}` `        ``// If all nodes satisfy the sum tree property,``        ``// return true``        ``return` `true``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Example usage``        ``TreeNode root = ``new` `TreeNode(``26``);``        ``root.left = ``new` `TreeNode(``10``);``        ``root.right = ``new` `TreeNode(``3``);``        ``root.left.left = ``new` `TreeNode(``4``);``        ``root.left.right = ``new` `TreeNode(``6``);``        ``root.right.right = ``new` `TreeNode(``3``);` `        ``if` `(isSumTree(root)) {``            ``System.out.println(``                ``"Given binary tree is a sum tree."``);``        ``}``        ``else` `{``            ``System.out.println(``                ``"Given binary tree is not a sum tree."``);``        ``}``    ``}``}` `// The code is contributed by Nidhi goel.`

## Python3

 `# Pyhton program for the above approach` `from` `queue ``import` `Queue` `# Definition for a binary tree node.`  `class` `TreeNode:``    ``def` `__init__(``self``, x):``        ``self``.val ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# function to check if given binary tree is sumtree or not`  `def` `isSumTree(root: TreeNode) ``-``> ``bool``:``    ``# If root is None or it's a leaf node, return True``    ``if` `root ``is` `None` `or` `(root.left ``is` `None` `and` `root.right ``is` `None``):``        ``return` `True` `    ``# Create an empty queue and add the root node to it``    ``q ``=` `Queue()``    ``q.put(root)` `    ``while` `not` `q.empty():``        ``# Remove the front node from the queue``        ``curr ``=` `q.get()` `        ``# If the node is a leaf node, continue``        ``if` `curr.left ``is` `None` `and` `curr.right ``is` `None``:``            ``continue` `        ``# Calculate the sum of the left and right subtrees``        ``sum` `=` `0``        ``if` `curr.left ``is` `not` `None``:``            ``sum` `+``=` `curr.left.val``            ``q.put(curr.left)``        ``if` `curr.right ``is` `not` `None``:``            ``sum` `+``=` `curr.right.val``            ``q.put(curr.right)` `        ``# If the sum of the left and right subtrees is not``        ``# equal to the value of the node, return False``        ``if` `sum` `!``=` `curr.val:``            ``return` `False` `    ``# If all nodes satisfy the sum tree property, return True``    ``return` `True`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``# Example usage``    ``root ``=` `TreeNode(``26``)``    ``root.left ``=` `TreeNode(``10``)``    ``root.right ``=` `TreeNode(``3``)``    ``root.left.left ``=` `TreeNode(``4``)``    ``root.left.right ``=` `TreeNode(``6``)``    ``root.right.right ``=` `TreeNode(``3``)` `    ``if` `isSumTree(root):``        ``print``(``"Given binary tree is a sum tree."``)``    ``else``:``        ``print``(``"Given binary tree is not a sum tree."``)` `# This code is contributed by rishab`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// Definition for a binary tree node.``public` `class` `TreeNode {``    ``public` `int` `val;``    ``public` `TreeNode left;``    ``public` `TreeNode right;` `    ``public` `TreeNode(``int` `x)``    ``{``        ``val = x;``        ``left = ``null``;``        ``right = ``null``;``    ``}``}` `public` `class` `Solution {``    ``// function to check if given binary tree is sumtree or``    ``// not``    ``public` `static` `bool` `isSumTree(TreeNode root)``    ``{``        ``// If root is NULL or it's a leaf node, return true``        ``if` `(root == ``null``            ``|| (root.left == ``null` `&& root.right == ``null``)) {``            ``return` `true``;``        ``}` `        ``// Create an empty queue and add the root node to it``        ``Queue q = ``new` `Queue();``        ``q.Enqueue(root);` `        ``while` `(q.Count > 0) {``            ``// Remove the front node from the queue``            ``TreeNode curr = q.Dequeue();` `            ``// If the node is a leaf node, continue``            ``if` `(curr.left == ``null` `&& curr.right == ``null``) {``                ``continue``;``            ``}` `            ``// Calculate the sum of the left and right``            ``// subtrees``            ``int` `sum = 0;``            ``if` `(curr.left != ``null``) {``                ``sum += curr.left.val;``                ``q.Enqueue(curr.left);``            ``}``            ``if` `(curr.right != ``null``) {``                ``sum += curr.right.val;``                ``q.Enqueue(curr.right);``            ``}` `            ``// If the sum of the left and right subtrees is``            ``// not equal to the value of the node, return``            ``// false``            ``if` `(sum != curr.val) {``                ``return` `false``;``            ``}``        ``}` `        ``// If all nodes satisfy the sum tree property,``        ``// return true``        ``return` `true``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``// Example usage``        ``TreeNode root = ``new` `TreeNode(26);``        ``root.left = ``new` `TreeNode(10);``        ``root.right = ``new` `TreeNode(3);``        ``root.left.left = ``new` `TreeNode(4);``        ``root.left.right = ``new` `TreeNode(6);``        ``root.right.right = ``new` `TreeNode(3);` `        ``if` `(isSumTree(root)) {``            ``Console.WriteLine(``                ``"Given binary tree is a sum tree."``);``        ``}``        ``else` `{``            ``Console.WriteLine(``                ``"Given binary tree is not a sum tree."``);``        ``}``    ``}``}``// This code is contributed by sarojmcy2e`

## Javascript

 `// Javascript program for the above approach` `// from queue import Queue` `// Definition for a binary tree node.``class TreeNode{``    ` `    ``constructor(x){``        ``this``.val = x;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}`  `// function to check if given binary tree is sumtree or not``function` `isSumTree(TreeNode){``    ``// If root is None or it's a leaf node, return True``    ``if``(root == ``null` `|| (root.left == ``null` `&& root.right == ``null``)) ``return` `true``;`  `    ``// Create an empty queue and add the root node to it``    ``let q =[];``    ``q.push(root)` `    ``while``(q.length > 0){``        ``// Remove the front node from the queue``        ``let curr = q[0];` `        ``// If the node is a leaf node, continue``        ``if``(curr.left == ``null` `&& curr.right == ``null``)``            ``continue``;` `        ``// Calculate the sum of the left and right subtrees``        ``let sum = 0;``        ``if``(curr.left != ``null``)``            ``sum += curr.left.val;``            ``q.push(curr.left);``        ``if``(curr.right != ``null``)``            ``sum += curr.right.val;``            ``q.push(curr.right);` `        ``// If the sum of the left and right subtrees is not``        ``// equal to the value of the node, return False``        ``if``(sum != curr.val)``            ``return` `false``;` `    ``}``    ``// If all nodes satisfy the sum tree property, return True``    ``return` `true``;``}` `// Driver Code``// Example usage``let root = ``new` `TreeNode(26);``root.left = ``new` `TreeNode(10);``root.right = ``new` `TreeNode(3);``root.left.left = ``new` `TreeNode(4);``root.left.right = ``new` `TreeNode(6);``root.right.right = ``new` `TreeNode(3);` `if``(isSumTree(root))``    ``console.log(``"Given binary tree is a sum tree."``);``else``    ``console.log(``"Given binary tree is not a sum tree."``);` `// This code is contributed by Nidhi goel.`

Output

`Given binary tree is not a sum tree.`

Time Complexity: O(n), where n is the number of nodes in the binary tree.
Space Complexity: O(n), where n is the number of nodes in the binary tree.

My Personal Notes arrow_drop_up