# Find height of a special binary tree whose leaf nodes are connected

Given a special binary tree whose leaf nodes are connected to form a circular doubly linked list, find its height.

For example,

```
1
/   \
2      3
/  \
4    5
/
6
```

In the above binary tree, 6, 5 and 3 are leaf nodes and they form a circular doubly linked list. Here, the left pointer of leaf node will act as a previous pointer of circular doubly linked list and its right pointer will act as next pointer of circular doubly linked list.

## Recommended: Please solve it on PRACTICE first, before moving on to the solution.

The idea is to follow similar approach as we do for finding height of a normal binary tree. We recursively calculate height of left and right subtrees of a node and assign height to the node as max of the heights of two children plus 1. But left and right child of a leaf node are null for normal binary trees. But, here leaf node is a circular doubly linked list node. So for a node to be a leaf node, we check if node’s left’s right is pointing to the node and its right’s left is also pointing to the node itself.

Below is the implementation of above idea –

## C++

 `// C++ program to calculate height of a special tree ` `// whose leaf nodes forms a circular doubly linked list ` `#include ` `using` `namespace` `std; ` ` `  `// A binary tree Node ` `struct` `Node ` `{ ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// function to check if given node is a leaf node or node ` `bool` `isLeaf(Node* node) ` `{ ` `    ``// If given node's left's right is pointing to given node ` `    ``// and its right's left is pointing to the node itself ` `    ``// then it's a leaf ` `    ``return` `node->left && node->left->right == node && ` `           ``node->right && node->right->left == node; ` `} ` ` `  `/* Compute the height of a tree -- the number of ` `Nodes along the longest path from the root node ` `down to the farthest leaf node.*/` `int` `maxDepth(Node* node) ` `{ ` `    ``// if node is NULL, return 0 ` `    ``if` `(node == NULL) ` `        ``return` `0; ` ` `  `    ``// if node is a leaf node, return 1 ` `    ``if` `(isLeaf(node)) ` `        ``return` `1; ` ` `  `    ``// compute the depth of each subtree and take maximum ` `    ``return` `1 + max(maxDepth(node->left), maxDepth(node->right)); ` `} ` ` `  `// Helper function that allocates a new tree node ` `Node* newNode(``int` `data) ` `{ ` `    ``Node* node = ``new` `Node; ` `    ``node->data = data; ` `    ``node->left = NULL; ` `    ``node->right = NULL; ` ` `  `    ``return` `node; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``Node* root = newNode(1); ` ` `  `    ``root->left = newNode(2); ` `    ``root->right = newNode(3); ` `    ``root->left->left = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->left->left->left = newNode(6); ` ` `  `    ``// Given tree contains 3 leaf nodes ` `    ``Node *L1 = root->left->left->left; ` `    ``Node *L2 = root->left->right; ` `    ``Node *L3 = root->right; ` ` `  `    ``// create circular doubly linked list out of ` `    ``// leaf nodes of the tree ` ` `  `    ``// set next pointer of linked list ` `    ``L1->right = L2, L2->right = L3, L3->right = L1; ` ` `  `    ``// set prev pointer of linked list ` `    ``L3->left = L2, L2->left = L1, L1->left = L3; ` ` `  `    ``// calculate height of the tree ` `    ``cout << ``"Height of tree is "` `<< maxDepth(root); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to calculate height of a special tree  ` `// whose leaf nodes forms a circular doubly linked list ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `// User defined node class ` `class` `Node {  ` `      ``int` `data;  ` `      ``Node left, right;  ` `      ``// Constructor to create a new tree node  ` `      ``Node(``int` `key)  ` `      ``{  ` `           ``data = key;  ` `           ``left = right = ``null``;  ` `      ``}  ` `}  ` ` `  `class` `GFG { ` ` `  `      ``// function to check if given node is a leaf node or node  ` `      ``static` `boolean` `isLeaf(Node node) ` `      ``{ ` `             ``// If given node's left's right is pointing to given node ` `             ``// and its right's left is pointing to the node itself ` `             ``// then it's a leaf ` `             ``return` `(node.left != ``null` `&& node.left.right == node && ` `                    ``node.right != ``null` `&& node.right.left == node); ` `                      `  `      ``} ` `      ``/* Compute the height of a tree -- the number of  ` `      ``Nodes along the longest path from the root node  ` `      ``down to the farthest leaf node.*/` `      ``static` `int` `maxDepth(Node node) ` `      ``{ ` `             ``// if node is NULL, return 0 ` `             ``if` `(node == ``null``) ` `                 ``return` `0``; ` ` `  `             ``// if node is a leaf node, return 1 ` `             ``if` `(isLeaf(node)) ` `                 ``return` `1``; ` ` `  `             ``// compute the depth of each subtree and take maximum ` `             ``return` `1` `+ Math.max(maxDepth(node.left), maxDepth(node.right)); ` `      ``} ` ` `  `      ``// Driver code ` `      ``public` `static` `void` `main(String args[]) ` `      ``{ ` `             ``Node root = ``new` `Node(``1``); ` `             `  `             ``root.left = ``new` `Node(``2``); ` `             ``root.right = ``new` `Node(``3``); ` `             ``root.left.left = ``new` `Node(``4``); ` `             ``root.left.right = ``new` `Node(``5``); ` `             ``root.left.left.left = ``new` `Node(``6``); ` ` `  `             ``// Given tree contains 3 leaf nodes ` `             ``Node L1 = root.left.left.left; ` `             ``Node L2 = root.left.right; ` `             ``Node L3 = root.right; ` ` `  `             ``// create circular doubly linked list out of  ` `             ``// leaf nodes of the tree ` `         `  `             ``// set next pointer of linked list ` `             ``L1.right = L2; L2.right = L3; L3.right = L1; ` ` `  `             ``// set prev pointer of linked list ` `             ``L3.left = L2; L2.left = L1; L1.left = L3; ` ` `  `             ``// calculate height of the tree ` `             ``System.out.println(``"Height of tree is "` `+ maxDepth(root)); ` `      ``} ` `} ` `// This code is contibuted by rachana soma  `

## Python3

 `""" program to Delete a Tree """` `  `  `# Helper function that allocates a new  ` `# node with the given data and None  ` `# left and right poers.                                   ` `class` `newNode:  ` `  `  `    ``# Construct to create a new node  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.data ``=` `key ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `  `  `# function to check if given node is a leaf node or node  ` `def` `isLeaf( node) : ` `  `  `    ``# If given node's left's right is pointing to given node  ` `    ``# and its right's left is pointing to the node itself  ` `    ``# then it's a leaf  ` `    ``return` `node.left ``and` `node.left.right ``=``=` `node ``and` `\ ` `           ``node.right ``and` `node.right.left ``=``=` `node  ` `  `  `   `  `""" Compute the height of a tree -- the number of  ` `Nodes along the longest path from the root node  ` `down to the farthest leaf node."""` `def` `maxDepth( node) : ` `  `  `    ``# if node is None, return 0  ` `    ``if` `(node ``=``=` `None``):  ` `        ``return` `0`  `   `  `    ``# if node is a leaf node, return 1  ` `    ``if` `(isLeaf(node)) : ` `        ``return` `1`  `   `  `    ``# compute the depth of each subtree and take maximum  ` `    ``return` `1` `+` `max``(maxDepth(node.left), maxDepth(node.right))  ` `  `  `  `  `  `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``root ``=` `newNode(``1``)  ` `   `  `    ``root.left ``=` `newNode(``2``)  ` `    ``root.right ``=` `newNode(``3``)  ` `    ``root.left.left ``=` `newNode(``4``)  ` `    ``root.left.right ``=` `newNode(``5``)  ` `    ``root.left.left.left ``=` `newNode(``6``)  ` `   `  `    ``# Given tree contains 3 leaf nodes  ` `    ``L1 ``=` `root.left.left.left  ` `    ``L2 ``=` `root.left.right  ` `    ``L3 ``=` `root.right  ` `   `  `    ``# create circular doubly linked list out of  ` `    ``# leaf nodes of the tree  ` `   `  `    ``# set next pointer of linked list  ` `    ``L1.right ``=` `L2 ` `    ``L2.right ``=` `L3 ` `    ``L3.right ``=` `L1  ` `   `  `    ``# set prev pointer of linked list  ` `    ``L3.left ``=` `L2 ` `    ``L2.left ``=` `L1 ` `    ``L1.left ``=` `L3  ` `   `  `    ``# calculate height of the tree  ` `    ``print``(``"Height of tree is "``,maxDepth(root)) ` `  `  `# This code is contributed by ` `# Shubham Singh(SHUBHAMSINGH10) `

## C#

 `// C# implementation to calculate height of a special tree  ` `// whose leaf nodes forms a circular doubly linked list ` `using` `System; ` ` `  `// User defined node class ` `public` `class` `Node {  ` `      ``public` `int` `data;  ` `      ``public` `Node left, right;  ` `      ``// Constructor to create a new tree node  ` `      ``public` `Node(``int` `key)  ` `      ``{  ` `           ``data = key;  ` `           ``left = right = ``null``;  ` `      ``}  ` `}  ` `  `  `public` `class` `GFG { ` `  `  `      ``// function to check if given node is a leaf node or node  ` `      ``static` `bool` `isLeaf(Node node) ` `      ``{ ` `             ``// If given node's left's right is pointing to given node ` `             ``// and its right's left is pointing to the node itself ` `             ``// then it's a leaf ` `             ``return` `(node.left != ``null` `&& node.left.right == node && ` `                    ``node.right != ``null` `&& node.right.left == node); ` `                       `  `      ``} ` `      ``/* Compute the height of a tree -- the number of  ` `      ``Nodes along the longest path from the root node  ` `      ``down to the farthest leaf node.*/` `      ``static` `int` `maxDepth(Node node) ` `      ``{ ` `             ``// if node is NULL, return 0 ` `             ``if` `(node == ``null``) ` `                 ``return` `0; ` `  `  `             ``// if node is a leaf node, return 1 ` `             ``if` `(isLeaf(node)) ` `                 ``return` `1; ` `  `  `             ``// compute the depth of each subtree and take maximum ` `             ``return` `1 + Math.Max(maxDepth(node.left), maxDepth(node.right)); ` `      ``} ` `  `  `      ``// Driver code ` `      ``public` `static` `void` `Main(String []args) ` `      ``{ ` `             ``Node root = ``new` `Node(1); ` `              `  `             ``root.left = ``new` `Node(2); ` `             ``root.right = ``new` `Node(3); ` `             ``root.left.left = ``new` `Node(4); ` `             ``root.left.right = ``new` `Node(5); ` `             ``root.left.left.left = ``new` `Node(6); ` `  `  `             ``// Given tree contains 3 leaf nodes ` `             ``Node L1 = root.left.left.left; ` `             ``Node L2 = root.left.right; ` `             ``Node L3 = root.right; ` `  `  `             ``// create circular doubly linked list out of  ` `             ``// leaf nodes of the tree ` `          `  `             ``// set next pointer of linked list ` `             ``L1.right = L2; L2.right = L3; L3.right = L1; ` `  `  `             ``// set prev pointer of linked list ` `             ``L3.left = L2; L2.left = L1; L1.left = L3; ` `  `  `             ``// calculate height of the tree ` `             ``Console.WriteLine(``"Height of tree is "` `+ maxDepth(root)); ` `      ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```Height of tree is 4
```

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 arrow_drop_up

Article Tags :
Practice Tags :

9

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.