// C++ program to calculate height of a special tree   // whose leaf nodes forms a circular doubly linked list   #include          using     namespace     std  ;   class     Node     {   public  :      int     data  ;      Node     *  left       *  right  ;      Node  (  int     x  )     {      data     =     x  ;      left     =     nullptr  ;      right     =     nullptr  ;      }   };   // function to check if given    // node is a leaf node or node   bool     isLeaf  (  Node  *     node  )     {          // For a node to be a leaf node it should      // satisfy the following two conditions:      // 1. Node's left's right pointer should be       // current node.      // 2. Node's right's left pointer should be       // current node.          // If one condition is met it is guaranteed      // that the other consition is also true.      return     node  ->  left     &&     node  ->  left  ->  right     ==     node      &&     node  ->  right     &&     node  ->  right  ->  left     ==     node  ;   }   // Compute the height of a tree    int     findTreeHeight  (  Node  *     node  )     {          // if node is NULL return -1.      if     (  node     ==     nullptr  )      return     -1  ;      // if node is a leaf node return 0      if     (  isLeaf  (  node  ))      return     0  ;      // compute the depth of each subtree      // and take maximum      return     1     +     max  (  findTreeHeight  (  node  ->  left  )         findTreeHeight  (  node  ->  right  ));   }   int     main  ()     {          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  ;      cout      < <     findTreeHeight  (  root  );      return     0  ;   }   

   // C program to calculate height of a special tree   // whose leaf nodes forms a circular doubly linked list   #include         #include         struct     Node     {      int     data  ;      struct     Node     *  left       *  right  ;   };   // function to check if given    // node is a leaf node or node   int     isLeaf  (  struct     Node  *     node  )     {          // For a node to be a leaf node it should      // satisfy the following two conditions:      // 1. Node's left's right pointer should be       // current node.      // 2. Node's right's left pointer should be       // current node.          // If one condition is met it is guaranteed      // that the other condition is also true.      return     node  ->  left     &&     node  ->  left  ->  right     ==     node      &&     node  ->  right     &&     node  ->  right  ->  left     ==     node  ;   }   // Compute the height of a tree    int     findTreeHeight  (  struct     Node  *     node  )     {          // if node is NULL return -1.      if     (  node     ==     NULL  )      return     -1  ;      // if node is a leaf node return 0      if     (  isLeaf  (  node  ))      return     0  ;      // compute the depth of each subtree and take maximum      int     leftDepth     =     findTreeHeight  (  node  ->  left  );      int     rightDepth     =     findTreeHeight  (  node  ->  right  );      return     1     +     (  leftDepth     >     rightDepth     ?     leftDepth     :     rightDepth  );   }   struct     Node  *     createNode  (  int     data  )     {      struct     Node  *     newNode     =         (  struct     Node  *  )  malloc  (  sizeof  (  struct     Node  ));      newNode  ->  data     =     data  ;      newNode  ->  left     =     NULL  ;      newNode  ->  right     =     NULL  ;      return     newNode  ;   }   int     main  ()     {          struct     Node  *     root     =     createNode  (  1  );      root  ->  left     =     createNode  (  2  );      root  ->  right     =     createNode  (  3  );      root  ->  left  ->  left     =     createNode  (  4  );      root  ->  left  ->  right     =     createNode  (  5  );      root  ->  left  ->  left  ->  left     =     createNode  (  6  );      // Given tree contains 3 leaf nodes      struct     Node  *     l1     =     root  ->  left  ->  left  ->  left  ;      struct     Node  *     l2     =     root  ->  left  ->  right  ;      struct     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  ;      printf  (  '%d'       findTreeHeight  (  root  ));      return     0  ;   }   

   // Java program to calculate height of a special tree   // whose leaf nodes forms a circular doubly linked list   class   Node     {      int     data  ;      Node     left       right  ;      Node  (  int     x  )     {      data     =     x  ;      left     =     null  ;      right     =     null  ;      }   }   class   GfG     {      // function to check if given       // node is a leaf node or node      static     boolean     isLeaf  (  Node     node  )     {          // For a node to be a leaf node it should      // satisfy the following two conditions:      // 1. Node's left's right pointer should be       // current node.      // 2. Node's right's left pointer should be       // current node.          // If one condition is met it is guaranteed      // that the other condition is also true.      return     node  .  left     !=     null     &&     node  .  left  .  right     ==     node      &&     node  .  right     !=     null     &&     node  .  right  .  left     ==     node  ;      }      // Compute the height of a tree       static     int     findTreeHeight  (  Node     node  )     {          // if node is NULL return -1.      if     (  node     ==     null  )      return     -  1  ;      // if node is a leaf node return 0      if     (  isLeaf  (  node  ))      return     0  ;      // compute the depth of each subtree and take maximum      return     1     +     Math  .  max  (  findTreeHeight  (  node  .  left  )         findTreeHeight  (  node  .  right  ));      }      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  ;      System  .  out  .  println  (  findTreeHeight  (  root  ));      }   }   

   # Python program to calculate height of a special tree   # whose leaf nodes forms a circular doubly linked list   class   Node  :   def   __init__  (  self     data  ):   self  .  data   =   data   self  .  left   =   None   self  .  right   =   None   # function to check if given    # node is a leaf node or node   def   isLeaf  (  node  ):   # For a node to be a leaf node it should   # satisfy the following two conditions:   # 1. Node's left's right pointer should be    # current node.   # 2. Node's right's left pointer should be    # current node.   # If one condition is met it is guaranteed   # that the other condition is also true.   return   (  node  .  left   and   node  .  left  .  right   ==   node   and   node  .  right   and   node  .  right  .  left   ==   node  )   # Compute the height of a tree    def   findTreeHeight  (  node  ):   # if node is NULL return -1.   if   node   is   None  :   return   -  1   # if node is a leaf node return 0   if   isLeaf  (  node  ):   return   0   # compute the depth of each subtree and take maximum   return   1   +   max  (  findTreeHeight  (  node  .  left  )   findTreeHeight  (  node  .  right  ))   if   __name__   ==   '__main__'  :   root   =   Node  (  1  )   root  .  left   =   Node  (  2  )   root  .  right   =   Node  (  3  )   root  .  left  .  left   =   Node  (  4  )   root  .  left  .  right   =   Node  (  5  )   root  .  left  .  left  .  left   =   Node  (  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   print  (  findTreeHeight  (  root  ))   

   // C# program to calculate height of a special tree   // whose leaf nodes forms a circular doubly linked list   using     System  ;   class     Node     {      public     int     data  ;      public     Node     left       right  ;      public     Node  (  int     x  )     {      data     =     x  ;      left     =     null  ;      right     =     null  ;      }   }   class     GfG     {      // function to check if given       // node is a leaf node or node      static     bool     isLeaf  (  Node     node  )     {          // For a node to be a leaf node it should      // satisfy the following two conditions:      // 1. Node's left's right pointer should be       // current node.      // 2. Node's right's left pointer should be       // current node.          // If one condition is met it is guaranteed      // that the other condition is also true.      return     node  .  left     !=     null     &&     node  .  left  .  right     ==     node      &&     node  .  right     !=     null     &&     node  .  right  .  left     ==     node  ;      }      // Compute the height of a tree       static     int     findTreeHeight  (  Node     node  )     {          // if node is NULL return -1.      if     (  node     ==     null  )      return     -  1  ;      // if node is a leaf node return 0      if     (  isLeaf  (  node  ))      return     0  ;      // compute the depth of each subtree and take maximum      return     1     +     Math  .  Max  (  findTreeHeight  (  node  .  left  )     findTreeHeight  (  node  .  right  ));      }      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  ;      Console  .  WriteLine  (  findTreeHeight  (  root  ));      }   }   

   // JavaScript program to calculate height of a special tree   // whose leaf nodes forms a circular doubly linked list   class     Node     {      constructor  (  data  )     {      this  .  data     =     data  ;      this  .  left     =     null  ;      this  .  right     =     null  ;      }   }   // function to check if given    // node is a leaf node or node   function     isLeaf  (  node  )     {          // For a node to be a leaf node it should      // satisfy the following two conditions:      // 1. Node's left's right pointer should be       // current node.      // 2. Node's right's left pointer should be       // current node.          // If one condition is met it is guaranteed      // that the other condition is also true.      return     node  .  left     &&     node  .  left  .  right     ===     node      &&     node  .  right     &&     node  .  right  .  left     ===     node  ;   }   // Compute the height of a tree    function     findTreeHeight  (  node  )     {          // if node is NULL return -1.      if     (  node     ===     null  )      return     -  1  ;      // if node is a leaf node return 0      if     (  isLeaf  (  node  ))      return     0  ;      // compute the depth of each subtree and take maximum      return     1     +     Math  .  max  (  findTreeHeight  (  node  .  left  )     findTreeHeight  (  node  .  right  ));   }   const     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   const     l1     =     root  .  left  .  left  .  left  ;   const     l2     =     root  .  left  .  right  ;   const     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  ;   console  .  log  (  findTreeHeight  (  root  ));