Path length having maximum number of bends

30 Mar, 2022
Given a binary tree, find the path length having maximum number of bends. Note: Here, bend indicates switching from left to right or vice versa while traversing in the tree. For example, consider below paths (L means moving leftwards, R means moving rightwards): LLRRRR – 1 Bend RLLLRR – 2 Bends LRLRLR – 5 BendsPrerequisite : Finding Max path length in a Binary TreeExamples:  
Input : 
            4
          /   \
        2      6
      /  \    / \
    1     3  5   7
                /
               9
              / \
             12 10
                  \
                  11
                  / \
                45  13
                      \
                      14

Output : 6
In the above example, the path 4-> 6-> 7-> 9-> 10-> 11-> 45
is having the maximum number of bends, i.e., 3. 
The length of this path is 6. 
 
Approach : The idea is to traverse the tree for left and right subtrees of the root. While traversing, keep track of the direction of motion (left or right). Whenever, direction of motion changes from left to right or vice versa increment the number of bends in the current path by 1. On reaching the leaf node, compare the number of bends in the current path with the maximum number of bends(i.e., maxBends) seen so far in a root-to-leaf path. If the number of bends in the current path is greater than the maxBends, then update the maxBends equal to the number of bends in the current path and update the maximum path length (i.e., len) also to the length of the current path.Implementation :  
C++
Java
Python3
C#
Javascript
// C++ program to find path length// having maximum number of bends#include <bits/stdc++.h>using namespace std; // structure nodestruct Node {    int key;    struct Node* left;    struct Node* right;}; // Utility function to create a new nodestruct Node* newNode(int key){    struct Node* node = new Node();    node->left = NULL;    node->right = NULL;    node->key = key;     return node;} /* Recursive function to calculate the pathlength having maximum number of bends.The following are parameters for this function. node --> pointer to the current nodedir --> determines whether the current nodeis left or right child of it's parent nodebends --> number of bends so far in thecurrent path.maxBends --> maximum number of bends in apath from root to leafsoFar --> length of the current path sofar traversedlen --> length of the path having maximumnumber of bends*/void findMaxBendsUtil(struct Node* node,                      char dir, int bends,                      int* maxBends, int soFar,                      int* len){    // Base Case    if (node == NULL)        return;     // Leaf node    if (node->left == NULL && node->right == NULL) {        if (bends > *maxBends) {            *maxBends = bends;            *len = soFar;        }    }    // Recurring for both left and right child    else {        if (dir == 'l') {            findMaxBendsUtil(node->left, dir,                             bends, maxBends,                             soFar + 1, len);            findMaxBendsUtil(node->right, 'r',                             bends + 1, maxBends,                             soFar + 1, len);        }        else {            findMaxBendsUtil(node->right, dir,                             bends, maxBends,                             soFar + 1, len);            findMaxBendsUtil(node->left, 'l',                             bends + 1, maxBends,                             soFar + 1, len);        }    }} // Helper function to call findMaxBendsUtil()int findMaxBends(struct Node* node){    if (node == NULL)        return 0;     int len = 0, bends = 0, maxBends = -1;     // Call for left subtree of the root    if (node->left)        findMaxBendsUtil(node->left, 'l',                         bends, &maxBends, 1, &len);     // Call for right subtree of the root    if (node->right)        findMaxBendsUtil(node->right, 'r', bends,                         &maxBends, 1, &len);     // Include the root node as well in the path length    len++;     return len;} // Driver codeint main(){    /* Constructed binary tree is      10      / \     8    2    / \  /    3  5 2          \           1          /         9    */     struct Node* root = newNode(10);    root->left = newNode(8);    root->right = newNode(2);    root->left->left = newNode(3);    root->left->right = newNode(5);    root->right->left = newNode(2);    root->right->left->right = newNode(1);    root->right->left->right->left = newNode(9);     cout << findMaxBends(root) - 1;     return 0;}
// Java program to find path length// having maximum number of bendsimport java.util.*;class GFG{   // structure node  static class Node  {    int key;    Node left;    Node right;  };   // Utility function to create a new node  static Node newNode(int key)  {    Node node = new Node();    node.left = null;    node.right = null;    node.key = key;    return node;  }   /* Recursive function to calculate the pathlength having maximum number of bends.The following are parameters for this function. node -. pointer to the current nodedir -. determines whether the current nodeis left or right child of it's parent nodebends -. number of bends so far in thecurrent path.maxBends -. maximum number of bends in apath from root to leafsoFar -. length of the current path sofar traversedlen -. length of the path having maximumnumber of bends*/  static int maxBends;  static int len;  private static final char LEFT = 'l';  private static final char RIGHT = 'r';     static void findMaxBendsUtil(Node node,                               char dir, int bends,                               int lenSoFar)  {         // Base Case    if (node == null)      return;     // Leaf node    if (node.left == null && node.right == null)    {      if (bends > maxBends)      {        maxBends = bends;        len = lenSoFar;      }    }     // Recurring for both left and right child    else    {      if (dir == LEFT)      {        findMaxBendsUtil(node.left, dir,                         bends,                         lenSoFar + 1);        findMaxBendsUtil(node.right, RIGHT,                         bends + 1,                         lenSoFar + 1);      }      else      {        findMaxBendsUtil(node.right, dir,                         bends,                         lenSoFar + 1);        findMaxBendsUtil(node.left, LEFT,                         bends + 1,                         lenSoFar + 1);      }    }  }   // Helper function to call findMaxBendsUtil()  static int findMaxBends(Node node)  {    if (node == null)      return 0;    len = 0;    maxBends = -1;    int bends = 0;     // Call for left subtree of the root    if (node.left != null)      findMaxBendsUtil(node.left, LEFT,                       bends, 1);     // Call for right subtree of the root    if (node.right != null)      findMaxBendsUtil(node.right, RIGHT, bends,                       1);     // Include the root node as well in the path length    len++;    return len;  }   // Driver code  public static void main(String[] args)  {    /* Constructed binary tree is      10      / \     8    2    / \  /    3  5 2          \           1          /         9    */     Node root = newNode(10);    root.left = newNode(8);    root.right = newNode(2);    root.left.left = newNode(3);    root.left.right = newNode(5);    root.right.left = newNode(2);    root.right.left.right = newNode(1);    root.right.left.right.left = newNode(9);     System.out.print(findMaxBends(root) - 1);  }} // This code is contributed by Rajput-Ji
# Python3 program to find path Length# having maximum number of bends # Utility function to create a new nodeclass newNode:    def __init__(self, key):        self.left = None        self.right = None        self.key = key # Recursive function to calculate the path# Length having maximum number of bends.# The following are parameters for this function.     # node -. pointer to the current node# Dir -. determines whether the current node# is left or right child of it's parent node# bends -. number of bends so far in the# current path.# maxBends -. maximum number of bends in a# path from root to leaf# soFar -. Length of the current path so# far traversed# Len -. Length of the path having maximum# number of bends def findMaxBendsUtil(node, Dir, bends,                     maxBends, soFar, Len):                              # Base Case    if (node == None):        return     # Leaf node    if (node.left == None and        node.right == None):        if (bends > maxBends[0]):            maxBends[0] = bends            Len[0] = soFar                                  # Having both left and right child    else:        if (Dir == 'l'):            findMaxBendsUtil(node.left, Dir, bends,                             maxBends, soFar + 1, Len)            findMaxBendsUtil(node.right, 'r', bends + 1,                             maxBends, soFar + 1, Len)        else:            findMaxBendsUtil(node.right, Dir, bends,                             maxBends, soFar + 1, Len)            findMaxBendsUtil(node.left, 'l', bends + 1,                             maxBends, soFar + 1, Len) # Helper function to call findMaxBendsUtil()def findMaxBends(node):    if (node == None):        return 0     Len = [0]    bends = 0    maxBends = [-1]     # Call for left subtree of the root    if (node.left):        findMaxBendsUtil(node.left, 'l', bends,                         maxBends, 1, Len)     # Call for right subtree of the root    if (node.right):        findMaxBendsUtil(node.right, 'r', bends,                         maxBends, 1, Len)     # Include the root node as well    # in the path Length    Len[0] += 1     return Len[0] # Driver codeif __name__ == '__main__':         # Constructed binary tree is    # 10    # / \    # 8 2    # / \ /    # 3 5 2    #     \    #     1    #     /    #     9    root = newNode(10)    root.left = newNode(8)    root.right = newNode(2)    root.left.left = newNode(3)    root.left.right = newNode(5)    root.right.left = newNode(2)    root.right.left.right = newNode(1)    root.right.left.right.left = newNode(9)     print(findMaxBends(root) - 1) # This code is contributed by PranchalK
// C# program to find path length// having maximum number of bendsusing System;public class GFG{   // structure node  public    class Node    {      public        int key;      public        Node left;      public        Node right;    };   // Utility function to create a new node  static Node newNode(int key)  {    Node node = new Node();    node.left = null;    node.right = null;    node.key = key;    return node;  }   /* Recursive function to calculate the pathlength having maximum number of bends.The following are parameters for this function. node -. pointer to the current nodedir -. determines whether the current nodeis left or right child of it's parent nodebends -. number of bends so far in thecurrent path.maxBends -. maximum number of bends in apath from root to leafsoFar -. length of the current path sofar traversedlen -. length of the path having maximumnumber of bends*/  static int maxBends;  static int len;  static void findMaxBendsUtil(Node node,                               char dir, int bends,                               int soFar)  {     // Base Case    if (node == null)      return;     // Leaf node    if (node.left == null && node.right == null)    {      if (bends > maxBends)      {        maxBends = bends;        len = soFar;      }    }     // Recurring for both left and right child    else    {      if (dir == 'l')      {        findMaxBendsUtil(node.left, dir,                         bends,                         soFar + 1);        findMaxBendsUtil(node.right, 'r',                         bends + 1,                         soFar + 1);      }      else      {        findMaxBendsUtil(node.right, dir,                         bends,                         soFar + 1);        findMaxBendsUtil(node.left, 'l',                         bends + 1,                         soFar + 1);      }    }  }   // Helper function to call findMaxBendsUtil()  static int findMaxBends(Node node)  {    if (node == null)      return 0;    len = 0;    maxBends = -1;    int bends = 0;     // Call for left subtree of the root    if (node.left != null)      findMaxBendsUtil(node.left, 'l',                       bends, 1);     // Call for right subtree of the root    if (node.right != null)      findMaxBendsUtil(node.right, 'r', bends,                       1);     // Include the root node as well in the path length    len++;    return len;  }   // Driver code  public static void Main(String[] args)  {     /* Constructed binary tree is      10      / \     8    2    / \  /    3  5 2          \           1          /         9    */     Node root = newNode(10);    root.left = newNode(8);    root.right = newNode(2);    root.left.left = newNode(3);    root.left.right = newNode(5);    root.right.left = newNode(2);    root.right.left.right = newNode(1);    root.right.left.right.left = newNode(9);     Console.Write(findMaxBends(root) - 1);  }} // This code is contributed by Rajput-Ji
<script>     // JavaScript program to find path length    // having maximum number of bends         class Node    {        constructor(key) {           this.left = null;           this.right = null;           this.key = key;        }    }     // Utility function to create a new node    function newNode(key)    {      let node = new Node(key);      return node;    }     /* Recursive function to calculate the path      length having maximum number of bends.      The following are parameters for this function.       node -. pointer to the current node      dir -. determines whether the current node      is left or right child of it's parent node      bends -. number of bends so far in the      current path.      maxBends -. maximum number of bends in a      path from root to leaf      soFar -. length of the current path so      far traversed      len -. length of the path having maximum      number of bends      */    let maxBends;    let len;    function findMaxBendsUtil(node, dir, bends, soFar)    {       // Base Case      if (node == null)        return;       // Leaf node      if (node.left == null && node.right == null)      {        if (bends > maxBends)        {          maxBends = bends;          len = soFar;        }      }       // Recurring for both left and right child      else      {        if (dir == 'l')        {          findMaxBendsUtil(node.left, dir,                           bends,                           soFar + 1);          findMaxBendsUtil(node.right, 'r',                           bends + 1,                           soFar + 1);        }        else        {          findMaxBendsUtil(node.right, dir,                           bends,                           soFar + 1);          findMaxBendsUtil(node.left, 'l',                           bends + 1,                           soFar + 1);        }      }    }     // Helper function to call findMaxBendsUtil()    function findMaxBends(node)    {      if (node == null)        return 0;      len = 0;      maxBends = -1;      let bends = 0;       // Call for left subtree of the root      if (node.left != null)        findMaxBendsUtil(node.left, 'l',                         bends, 1);       // Call for right subtree of the root      if (node.right != null)        findMaxBendsUtil(node.right, 'r', bends,                         1);       // Include the root node as well in the path length      len++;      return len;    }         /* Constructed binary tree is      10      / \     8    2    / \  /    3  5 2          \           1          /         9    */      let root = newNode(10);    root.left = newNode(8);    root.right = newNode(2);    root.left.left = newNode(3);    root.left.right = newNode(5);    root.right.left = newNode(2);    root.right.left.right = newNode(1);    root.right.left.right.left = newNode(9);      document.write(findMaxBends(root) - 1);   </script>
Output:  
4
 
PranchalKatiyar
arvindgarg
Rajput-Ji
mukesh07
code_ayush
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.