# Node Depth in Binary Tree — Competitive Programming with Time and Space Complexity

Question — 8(Level — Easy)

*Welcome to the competitive series of **Code Wrestling**. Today, we are gonna solve an easy problem,** **Node Depth in Binary Tree.*

*We will find the **Time and Space complexity** of our solution and will also guide you to the process of finding an **optimized solution**.*

Visit our YouTube channel for more interesting stuff **Code Wrestling****.**

# Question

The distance between a node in a Binary Tree and the tree’s root is called the node’s depth. Write a function that takes in a Binary Tree and returns the sum of its nodes depths.

Each BinaryTree node has an integer value, a left child node, and a right child node. Children nodes can either be BinaryTree nodes themselves or None / null.

# Sample Input:

Tree is given as:

# Sample Output:

16

// The depth of the node with value 2 is 1.

// The depth of the node with value 3 is 1.

// The depth of the node with value 4 is 2.

// The depth of the node with value 5 is 2.

// Etc..

// Summing all of these depths yields 16.

STOP HERE. And read the question again. Try to solve the question on your own and then proceed further to see our solution.

# Solution

The problem can be easily solved by using Recursion.

The above picture gives a little insight into how you can approach your solution.

At any level/depth, add the currentDepth + getAllLeftNodeDepth() + getAllRightNodeDepth()

See the below code snippet to understand the solution.

`private int GetDepth(BinaryTree tree, int depth)`

{

if (tree == null) return 0;

return depth + **GetDepth**(tree.**left**, depth + 1) +

**GetDepth**(tree.**right**, depth + 1);

}

The **time complexity** for the solution is **O(n)** because we have to traverse each element in the tree and the **space complexity** is also **O(h)** where h is the height of the binary tree in this case (it depends on how the tree looks like), because of the recursion.

In case if you don’t understand the solution well, I have a more descriptive solution just to make you understand the solution.

private int NodeDepth(BinaryTree tree, int depth, int sum)

{

// Intially depth is 0 ans um is 0

depth++;

if (tree.left != null)

{

sum = depth +NodeDepth(tree.left, depth, sum);

} if (tree.right != null)

{

sum = depth +NodeDepth(tree.right, depth, sum);

}

return sum;

}

Thank you so much for reading till the end. See you in the next article. Till then… **HAPPY LEARNING!!**

Do visit our YouTube channel Code Wrestling for more interesting stuff.