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.



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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to calculate height of a special tree
// whose leaf nodes forms a circular doubly linked list
#include <iostream>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

""" 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)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right



Output:

Height of tree is 4

This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


1


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