# Find sum of all nodes of the given perfect binary tree

Here given code implementation process.

``````/*
C Program
Find sum of all nodes of the given perfect binary tree
Recursive solution
*/

#include <stdio.h>
#include <stdlib.h>

//Binary Tree node
struct Node
{
int data;
struct Node *left, *right;
};

//This is creating a binary tree node and return this
struct Node *get_node(int data)
{
// Create dynamic node
struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
if (new_node != NULL)
{
//Set data and pointer values
new_node->data = data;
new_node->left = NULL;
new_node->right = NULL;
}
else
{
//This is indicates, segmentation fault or memory overflow problem
printf("Memory Overflow\n");
}
//return new node
return new_node;
}
//Display pre order elements
void preorder(struct Node *node)
{
if (node != NULL)
{
//Print node value
printf("  %d", node->data);
preorder(node->left);
preorder(node->right);
}
}

//Calculate min depth of binary tree
int min_depth(struct Node *node)
{
if (node == NULL)
{
return 0;
}
// Recursively, Finding the min height of nodes
int a = min_depth(node->left);
int b = min_depth(node->right);
if (a > b)
{
return b + 1;
}
else
{
return a + 1;
}
}

//Returns the sum of all nodes which are less than or equal to given level
int level_sum(struct Node *node, int k, int level)
{
if (node == NULL)
{
return 0;
}
if (k <= level)
{
// Calculate node sum
return node->data + level_sum(node->left, k + 1, level) + level_sum(node->right, k + 1, level);
}
else
{
return 0;
}
}

//Find the sum of nodes of binary tree which is perfect binary tree
int perfect_binary_tree_sum(struct Node *root)
{
if (root == NULL)
{
printf("\n Empty Binary Tree \n");
return 0;
}
//First find min depth in binary tree
int level = min_depth(root);
//It return sum of nodes which are exist in root to min depth
return level_sum(root, 1, level);
}

int main()
{
struct Node *root = NULL;
/*
constructor binary tree
-----------------------

6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
root = get_node(6);
root->left = get_node(7);
root->left->left = get_node(8);
root->left->right = get_node(10);
root->left->right->right = get_node(1);
root->left->right->right->left = get_node(9);
root->left->right->left = get_node(1);
root->right = get_node(3);
root->right->left = get_node(2);
root->right->right = get_node(1);
root->right->right->right = get_node(5);
root->right->right->left = get_node(4);
//Display Tree Element
printf("\n Tree Nodes : ");
preorder(root);
/*
Perfect form of above binary tree
-----------------------

6
/   \
/     \
7       3
/ \     /  \
8   10  2    1

-----------------------
*/
//Display Calculated Result
printf("\n Perfect binary tree sum :  %d \n", perfect_binary_tree_sum(root));
return 0;
}``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum :  37``````
``````/*
Java Program
Find the sum of the node having child node x
Recursive solution
*/
//Binary Tree node
class Node
{
public int data;
public Node left;
public Node right;
public Node(int data)
{
//set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public Node root;
public BinaryTree()
{
//Set initial tree root to null
this.root = null;
}
//Display pre order elements
public void preorder(Node node)
{
if (node != null)
{
//Print node value
System.out.print("  " + node.data);
preorder(node.left);
preorder(node.right);
}
}
//Calculate min depth of binary tree
public int min_depth(Node node)
{
if (node == null)
{
return 0;
}
// Recursively, Finding the min height of nodes
int a = min_depth(node.left);
int b = min_depth(node.right);
if (a > b)
{
return b + 1;
}
else
{
return a + 1;
}
}
//Returns the sum of all nodes which are less than or equal to given level
public int level_sum(Node node, int k, int level)
{
if (node == null)
{
return 0;
}
if (k <= level)
{
//Calculate node sum
return node.data + level_sum(node.left, k + 1, level) + level_sum(node.right, k + 1, level);
}
else
{
return 0;
}
}
//Find the sum of nodes of binary tree which is perfect binary tree
public int perfect_binary_tree_sum(Node root)
{
if (root == null)
{
System.out.print("\n Empty Binary Tree \n");
return 0;
}
//First find min depth in binary tree
int level = min_depth(root);
//It return sum of nodes which are exist in root to min depth
return level_sum(root, 1, level);
}
public static void main(String[] args)
{
//Make object of binary tree
BinaryTree tree = new BinaryTree();
/*
constructor binary tree
-----------------------

6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
tree.root = new Node(6);
tree.root.left = new Node(7);
tree.root.left.left = new Node(8);
tree.root.left.right = new Node(10);
tree.root.left.right.right = new Node(1);
tree.root.left.right.right.left = new Node(9);
tree.root.left.right.left = new Node(1);
tree.root.right = new Node(3);
tree.root.right.left = new Node(2);
tree.root.right.right = new Node(1);
tree.root.right.right.right = new Node(5);
tree.root.right.right.left = new Node(4);
//Display Tree Element
System.out.print("\n Tree Nodes : ");
tree.preorder(tree.root);
/*
Perfect form of above binary tree
-----------------------

6
/   \
/     \
7       3
/ \     /  \
8   10  2    1

-----------------------
*/
//Display Calculated Result
System.out.print("\n Perfect binary tree sum : " + tree.perfect_binary_tree_sum(tree.root) + " \n");
}
}``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum : 37``````
``````// Include header file
#include <iostream>

using namespace std;
/*
C++ Program
Find the sum of the node having child node x
Recursive solution
*/
// Binary Tree node
class Node
{
public: int data;
Node *left;
Node *right;
Node(int data)
{
// set node value
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
class BinaryTree
{
public: Node *root;
BinaryTree()
{
// Set initial tree root to null
this->root = NULL;
}
// Display pre order elements
void preorder(Node *node)
{
if (node != NULL)
{
// Print node value
cout << "  " << node->data;
this->preorder(node->left);
this->preorder(node->right);
}
}
// Calculate min depth of binary tree
int min_depth(Node *node)
{
if (node == NULL)
{
return 0;
}
//  Recursively, Finding the min height of nodes
int a = this->min_depth(node->left);
int b = this->min_depth(node->right);
if (a > b)
{
return b + 1;
}
else
{
return a + 1;
}
}
// Returns the sum of all nodes which are less than or equal to given level
int level_sum(Node *node, int k, int level)
{
if (node == NULL)
{
return 0;
}
if (k <= level)
{
// Calculate node sum
return node->data + this->level_sum(node->left, k + 1, level) + this->level_sum(node->right, k + 1, level);
}
else
{
return 0;
}
}
// Find the sum of nodes of binary tree which is perfect binary tree
int perfect_binary_tree_sum(Node *root)
{
if (root == NULL)
{
cout << "\n Empty Binary Tree \n";
return 0;
}
// First find min depth in binary tree
int level = this->min_depth(root);
// It return sum of nodes which are exist in root to min depth
return this->level_sum(root, 1, level);
}
};
int main()
{
// Make object of binary tree
BinaryTree tree = BinaryTree();
/*
constructor binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
tree.root = new Node(6);
tree.root->left = new Node(7);
tree.root->left->left = new Node(8);
tree.root->left->right = new Node(10);
tree.root->left->right->right = new Node(1);
tree.root->left->right->right->left = new Node(9);
tree.root->left->right->left = new Node(1);
tree.root->right = new Node(3);
tree.root->right->left = new Node(2);
tree.root->right->right = new Node(1);
tree.root->right->right->right = new Node(5);
tree.root->right->right->left = new Node(4);
// Display Tree Element
cout << "\n Tree Nodes : ";
tree.preorder(tree.root);
/*
Perfect form of above binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
-----------------------
*/
// Display Calculated Result
cout << "\n Perfect binary tree sum : " << tree.perfect_binary_tree_sum(tree.root) << " \n";
return 0;
}``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum : 37``````
``````//Include namespace system
using System;
/*
C# Program
Find the sum of the node having child node x
Recursive solution
*/
// Binary Tree node
public class Node
{
public int data;
public Node left;
public Node right;
public Node(int data)
{
// set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public Node root;
public BinaryTree()
{
// Set initial tree root to null
this.root = null;
}
// Display pre order elements
public void preorder(Node node)
{
if (node != null)
{
// Print node value
Console.Write("  " + node.data);
preorder(node.left);
preorder(node.right);
}
}
// Calculate min depth of binary tree
public int min_depth(Node node)
{
if (node == null)
{
return 0;
}
//  Recursively, Finding the min height of nodes
int a = min_depth(node.left);
int b = min_depth(node.right);
if (a > b)
{
return b + 1;
}
else
{
return a + 1;
}
}
// Returns the sum of all nodes which are less than or equal to given level
public int level_sum(Node node, int k, int level)
{
if (node == null)
{
return 0;
}
if (k <= level)
{
// Calculate node sum
return node.data + level_sum(node.left, k + 1, level) + level_sum(node.right, k + 1, level);
}
else
{
return 0;
}
}
// Find the sum of nodes of binary tree which is perfect binary tree
public int perfect_binary_tree_sum(Node root)
{
if (root == null)
{
Console.Write("\n Empty Binary Tree \n");
return 0;
}
// First find min depth in binary tree
int level = min_depth(root);
// It return sum of nodes which are exist in root to min depth
return level_sum(root, 1, level);
}
public static void Main(String[] args)
{
// Make object of binary tree
BinaryTree tree = new BinaryTree();
/*
constructor binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
tree.root = new Node(6);
tree.root.left = new Node(7);
tree.root.left.left = new Node(8);
tree.root.left.right = new Node(10);
tree.root.left.right.right = new Node(1);
tree.root.left.right.right.left = new Node(9);
tree.root.left.right.left = new Node(1);
tree.root.right = new Node(3);
tree.root.right.left = new Node(2);
tree.root.right.right = new Node(1);
tree.root.right.right.right = new Node(5);
tree.root.right.right.left = new Node(4);
// Display Tree Element
Console.Write("\n Tree Nodes : ");
tree.preorder(tree.root);
/*
Perfect form of above binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
-----------------------
*/
// Display Calculated Result
Console.Write("\n Perfect binary tree sum : " + tree.perfect_binary_tree_sum(tree.root) + " \n");
}
}``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum : 37``````
``````<?php
/*
Php Program
Find the sum of the node having child node x
Recursive solution
*/
// Binary Tree node
class Node
{
public \$data;
public \$left;
public \$right;

function __construct(\$data)
{
// set node value
\$this->data = \$data;
\$this->left = null;
\$this->right = null;
}
}
class BinaryTree
{
public \$root;

function __construct()
{
// Set initial tree root to null
\$this->root = null;
}
// Display pre order elements
public  function preorder(\$node)
{
if (\$node != null)
{
// Print node value
echo "  ". \$node->data;
\$this->preorder(\$node->left);
\$this->preorder(\$node->right);
}
}
// Calculate min depth of binary tree
public  function min_depth(\$node)
{
if (\$node == null)
{
return 0;
}
//  Recursively, Finding the min height of nodes
\$a = \$this->min_depth(\$node->left);
\$b = \$this->min_depth(\$node->right);
if (\$a > \$b)
{
return \$b + 1;
}
else
{
return \$a + 1;
}
}
// Returns the sum of all nodes which are less than or equal to given level
public  function level_sum(\$node, \$k, \$level)
{
if (\$node == null)
{
return 0;
}
if (\$k <= \$level)
{
// Calculate node sum
return \$node->data + \$this->level_sum(\$node->left, \$k + 1, \$level) +
\$this->level_sum(\$node->right, \$k + 1, \$level);
}
else
{
return 0;
}
}
// Find the sum of nodes of binary tree which is perfect binary tree
public  function perfect_binary_tree_sum(\$root)
{
if (\$root == null)
{
echo "\n Empty Binary Tree \n";
return 0;
}
// First find min depth in binary tree
\$level = \$this->min_depth(\$root);
// It return sum of nodes which are exist in root to min depth
return \$this->level_sum(\$root, 1, \$level);
}
}

function main()
{
// Make object of binary tree
\$tree = new BinaryTree();
/*
constructor binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
\$tree->root = new Node(6);
\$tree->root->left = new Node(7);
\$tree->root->left->left = new Node(8);
\$tree->root->left->right = new Node(10);
\$tree->root->left->right->right = new Node(1);
\$tree->root->left->right->right->left = new Node(9);
\$tree->root->left->right->left = new Node(1);
\$tree->root->right = new Node(3);
\$tree->root->right->left = new Node(2);
\$tree->root->right->right = new Node(1);
\$tree->root->right->right->right = new Node(5);
\$tree->root->right->right->left = new Node(4);
// Display Tree Element
echo "\n Tree Nodes : ";
\$tree->preorder(\$tree->root);
/*
Perfect form of above binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
-----------------------
*/
// Display Calculated Result
echo "\n Perfect binary tree sum : ". \$tree->perfect_binary_tree_sum(\$tree->root) ." \n";
}
main();``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum : 37``````
``````/*
Node Js Program
Find the sum of the node having child node x
Recursive solution
*/
// Binary Tree node
class Node
{
constructor(data)
{
// set node value
this.data = data;
this.left = null;
this.right = null;
}
}
class BinaryTree
{
constructor()
{
// Set initial tree root to null
this.root = null;
}
// Display pre order elements
preorder(node)
{
if (node != null)
{
// Print node value
process.stdout.write("  " + node.data);
this.preorder(node.left);
this.preorder(node.right);
}
}
// Calculate min depth of binary tree
min_depth(node)
{
if (node == null)
{
return 0;
}
//  Recursively, Finding the min height of nodes
var a = this.min_depth(node.left);
var b = this.min_depth(node.right);
if (a > b)
{
return b + 1;
}
else
{
return a + 1;
}
}
// Returns the sum of all nodes which are less than or equal to given level
level_sum(node, k, level)
{
if (node == null)
{
return 0;
}
if (k <= level)
{
// Calculate node sum
return node.data + this.level_sum(node.left, k + 1, level) +
this.level_sum(node.right, k + 1, level);
}
else
{
return 0;
}
}
// Find the sum of nodes of binary tree which is perfect binary tree
perfect_binary_tree_sum(root)
{
if (root == null)
{
process.stdout.write("\n Empty Binary Tree \n");
return 0;
}
// First find min depth in binary tree
var level = this.min_depth(root);
// It return sum of nodes which are exist in root to min depth
return this.level_sum(root, 1, level);
}
}

function main()
{
// Make object of binary tree
var tree = new BinaryTree();
/*
constructor binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
tree.root = new Node(6);
tree.root.left = new Node(7);
tree.root.left.left = new Node(8);
tree.root.left.right = new Node(10);
tree.root.left.right.right = new Node(1);
tree.root.left.right.right.left = new Node(9);
tree.root.left.right.left = new Node(1);
tree.root.right = new Node(3);
tree.root.right.left = new Node(2);
tree.root.right.right = new Node(1);
tree.root.right.right.right = new Node(5);
tree.root.right.right.left = new Node(4);
// Display Tree Element
process.stdout.write("\n Tree Nodes : ");
tree.preorder(tree.root);
/*
Perfect form of above binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
-----------------------
*/
// Display Calculated Result
process.stdout.write("\n Perfect binary tree sum : " + tree.perfect_binary_tree_sum(tree.root) + " \n");
}
main();``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum : 37``````
``````#     Python 3 Program
#     Find the sum of the node having child node x
#     Recursive solution

# Binary Tree node
class Node :

def __init__(self, data) :
# set node value
self.data = data
self.left = None
self.right = None

class BinaryTree :

def __init__(self) :
# Set initial tree root to null
self.root = None

# Display pre order elements
def preorder(self, node) :
if (node != None) :
# Print node value
print("  ", node.data, end = "")
self.preorder(node.left)
self.preorder(node.right)

# Calculate min depth of binary tree
def min_depth(self, node) :
if (node == None) :
return 0

#  Recursively, Finding the min height of nodes
a = self.min_depth(node.left)
b = self.min_depth(node.right)
if (a > b) :
return b + 1
else :
return a + 1

# Returns the sum of all nodes which are less than or equal to given level
def level_sum(self, node, k, level) :
if (node == None) :
return 0

if (k <= level) :
# Calculate node sum
return node.data + self.level_sum(node.left, k + 1, level) + self.level_sum(node.right, k + 1, level)
else :
return 0

# Find the sum of nodes of binary tree which is perfect binary tree
def perfect_binary_tree_sum(self, root) :
if (root == None) :
print("\n Empty Binary Tree \n", end = "")
return 0

# First find min depth in binary tree
level = self.min_depth(root)
# It return sum of nodes which are exist in root to min depth
return self.level_sum(root, 1, level)

def main() :
# Make object of binary tree
tree = BinaryTree()
#
# 		constructor binary tree
# 		-----------------------
# 		      6
# 		    /   \
# 		   /     \
# 		  7       3
# 		 / \     /  \
# 		8   10  2    1
# 		   /  \     / \
# 		  1    1   4   5
# 		      /
# 		     9
# 		-----------------------
#

tree.root = Node(6)
tree.root.left = Node(7)
tree.root.left.left = Node(8)
tree.root.left.right = Node(10)
tree.root.left.right.right = Node(1)
tree.root.left.right.right.left = Node(9)
tree.root.left.right.left = Node(1)
tree.root.right = Node(3)
tree.root.right.left = Node(2)
tree.root.right.right = Node(1)
tree.root.right.right.right = Node(5)
tree.root.right.right.left = Node(4)
# Display Tree Element
print("\n Tree Nodes : ", end = "")
tree.preorder(tree.root)
#
# 		    Perfect form of above binary tree
# 		    -----------------------
# 		          6
# 		        /   \
# 		       /     \
# 		      7       3
# 		     / \     /  \
# 		    8   10  2    1
# 		-----------------------
#

# Display Calculated Result
print("\n Perfect binary tree sum : ", tree.perfect_binary_tree_sum(tree.root) )

if __name__ == "__main__": main()``````

#### Output

`````` Tree Nodes :    6   7   8   10   1   1   9   3   2   1   4   5
Perfect binary tree sum :  37``````
``````#     Ruby Program
#     Find the sum of the node having child node x
#     Recursive solution

# Binary Tree node
class Node
# Define the accessor and reader of class Node
attr_accessor :data, :left, :right

def initialize(data)
# set node value
self.data = data
self.left = nil
self.right = nil
end

end

class BinaryTree
# Define the accessor and reader of class BinaryTree
attr_accessor :root

def initialize()
# Set initial tree root to null
self.root = nil
end

# Display pre order elements
def preorder(node)
if (node != nil)
# Print node value
print("  ", node.data)
self.preorder(node.left)
self.preorder(node.right)
end

end

# Calculate min depth of binary tree
def min_depth(node)
if (node == nil)
return 0
end

#  Recursively, Finding the min height of nodes
a = self.min_depth(node.left)
b = self.min_depth(node.right)
if (a > b)
return b + 1
else
return a + 1
end

end

# Returns the sum of all nodes which are less than or equal to given level
def level_sum(node, k, level)
if (node == nil)
return 0
end

if (k <= level)
# Calculate node sum
return node.data + self.level_sum(node.left, k + 1, level) + self.level_sum(node.right, k + 1, level)
else
return 0
end

end

# Find the sum of nodes of binary tree which is perfect binary tree
def perfect_binary_tree_sum(root)
if (root == nil)
print("\n Empty Binary Tree \n")
return 0
end

# First find min depth in binary tree
level = self.min_depth(root)
# It return sum of nodes which are exist in root to min depth
return self.level_sum(root, 1, level)
end

end

def main()
# Make object of binary tree
tree = BinaryTree.new()
#
# 		constructor binary tree
# 		-----------------------
# 		      6
# 		    /   \
# 		   /     \
# 		  7       3
# 		 / \     /  \
# 		8   10  2    1
# 		   /  \     / \
# 		  1    1   4   5
# 		      /
# 		     9
# 		-----------------------
#

tree.root = Node.new(6)
tree.root.left = Node.new(7)
tree.root.left.left = Node.new(8)
tree.root.left.right = Node.new(10)
tree.root.left.right.right = Node.new(1)
tree.root.left.right.right.left = Node.new(9)
tree.root.left.right.left = Node.new(1)
tree.root.right = Node.new(3)
tree.root.right.left = Node.new(2)
tree.root.right.right = Node.new(1)
tree.root.right.right.right = Node.new(5)
tree.root.right.right.left = Node.new(4)
# Display Tree Element
print("\n Tree Nodes : ")
tree.preorder(tree.root)
#
# 		    Perfect form of above binary tree
# 		    -----------------------
# 		          6
# 		        /   \
# 		       /     \
# 		      7       3
# 		     / \     /  \
# 		    8   10  2    1
# 		-----------------------
#

# Display Calculated Result
print("\n Perfect binary tree sum : ", tree.perfect_binary_tree_sum(tree.root) ," \n")
end

main()``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum : 37
``````
``````/*
Scala Program
Find the sum of the node having child node x
Recursive solution
*/

// Binary Tree node
class Node(var data: Int , var left: Node , var right: Node)
{
def this(data: Int)
{
this(data, null, null);
}
}
class BinaryTree(var root: Node)
{
def this()
{
this(null);
}
// Display pre order elements
def preorder(node: Node): Unit = {
if (node != null)
{
// Print node value
print("  " + node.data);
preorder(node.left);
preorder(node.right);
}
}
// Calculate min depth of binary tree
def min_depth(node: Node): Int = {
if (node == null)
{
return 0;
}
//  Recursively, Finding the min height of nodes
var a: Int = min_depth(node.left);
var b: Int = min_depth(node.right);
if (a > b)
{
return b + 1;
}
else
{
return a + 1;
}
}
// Returns the sum of all nodes which are less than or equal to given level
def level_sum(node: Node, k: Int, level: Int): Int = {
if (node == null)
{
return 0;
}
if (k <= level)
{
// Calculate node sum
return node.data +
level_sum(node.left, k + 1, level) +
level_sum(node.right, k + 1, level);
}
else
{
return 0;
}
}
// Find the sum of nodes of binary tree which is perfect binary tree
def perfect_binary_tree_sum(root: Node): Int = {
if (root == null)
{
print("\n Empty Binary Tree \n");
return 0;
}
// First find min depth in binary tree
var level: Int = min_depth(root);
// It return sum of nodes which are exist in root to min depth
return level_sum(root, 1, level);
}
}
object Main
{
def main(args: Array[String]): Unit = {
// Make object of binary tree
var tree: BinaryTree = new BinaryTree();
/*
constructor binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
tree.root = new Node(6);
tree.root.left = new Node(7);
tree.root.left.left = new Node(8);
tree.root.left.right = new Node(10);
tree.root.left.right.right = new Node(1);
tree.root.left.right.right.left = new Node(9);
tree.root.left.right.left = new Node(1);
tree.root.right = new Node(3);
tree.root.right.left = new Node(2);
tree.root.right.right = new Node(1);
tree.root.right.right.right = new Node(5);
tree.root.right.right.left = new Node(4);
// Display Tree Element
print("\n Tree Nodes : ");
tree.preorder(tree.root);
/*
Perfect form of above binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
-----------------------
*/
// Display Calculated Result
print("\n Perfect binary tree sum : " + tree.perfect_binary_tree_sum(tree.root) + " \n");
}
}``````

#### Output

`````` Tree Nodes :   6  7  8  10  1  1  9  3  2  1  4  5
Perfect binary tree sum : 37``````
``````/*
Swift 4 Program
Find the sum of the node having child node x
Recursive solution
*/

// Binary Tree node
class Node
{
var data: Int;
var left: Node? ;
var right: Node? ;
init(_ data: Int)
{
// set node value
self.data = data;
self.left = nil;
self.right = nil;
}
}
class BinaryTree
{
var root: Node? ;
init()
{
// Set initial tree root to null
self.root = nil;
}
// Display pre order elements
func preorder(_ node: Node? )
{
if (node != nil)
{
// Print node value
print("  ", node!.data, terminator: "");
self.preorder(node!.left);
self.preorder(node!.right);
}
}
// Calculate min depth of binary tree
func min_depth(_ node: Node? )->Int
{
if (node == nil)
{
return 0;
}
//  Recursively, Finding the min height of nodes
let a: Int = self.min_depth(node!.left);
let b: Int = self.min_depth(node!.right);
if (a > b)
{
return b + 1;
}
else
{
return a + 1;
}
}
// Returns the sum of all nodes which are less than or equal to given level
func level_sum(_ node: Node? , _ k : Int, _ level: Int)->Int
{
if (node == nil)
{
return 0;
}
if (k <= level)
{
// Calculate node sum
return node!.data +
self.level_sum(node!.left, k + 1, level) +
self.level_sum(node!.right, k + 1, level);
}
else
{
return 0;
}
}
// Find the sum of nodes of binary tree which is perfect binary tree
func perfect_binary_tree_sum(_ root: Node? )->Int
{
if (root == nil)
{
print("\n Empty Binary Tree \n", terminator: "");
return 0;
}
// First find min depth in binary tree
let level: Int = self.min_depth(root);
// It return sum of nodes which are exist in root to min depth
return self.level_sum(root, 1, level);
}
}
func main()
{
// Make object of binary tree
let tree: BinaryTree = BinaryTree();
/*
constructor binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
/  \     / \
1    1   4   5
/
9
-----------------------
*/
tree.root = Node(6);
tree.root!.left = Node(7);
tree.root!.left!.left = Node(8);
tree.root!.left!.right = Node(10);
tree.root!.left!.right!.right = Node(1);
tree.root!.left!.right!.right!.left = Node(9);
tree.root!.left!.right!.left = Node(1);
tree.root!.right = Node(3);
tree.root!.right!.left = Node(2);
tree.root!.right!.right = Node(1);
tree.root!.right!.right!.right = Node(5);
tree.root!.right!.right!.left = Node(4);
// Display Tree Element
print("\n Tree Nodes : ", terminator: "");
tree.preorder(tree.root);
/*
Perfect form of above binary tree
-----------------------
6
/   \
/     \
7       3
/ \     /  \
8   10  2    1
-----------------------
*/
// Display Calculated Result
print("\n Perfect binary tree sum : ", tree.perfect_binary_tree_sum(tree.root) ," \n", terminator: "");
}
main();``````

#### Output

`````` Tree Nodes :    6   7   8   10   1   1   9   3   2   1   4   5
Perfect binary tree sum :  37``````

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

### New Comment 