Skip to content
Related Articles

Related Articles

Improve Article

Path length having maximum number of bends

  • Difficulty Level : Medium
  • Last Updated : 30 Jun, 2021

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 Bends
Prerequisite : Finding Max path length in a Binary Tree
Examples: 
 

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




// C++ program to find path length
// having maximum number of bends
#include <bits/stdc++.h>
using namespace std;
 
// structure node
struct Node {
    int key;
    struct Node* left;
    struct Node* right;
};
 
// Utility function to create a new node
struct 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 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
*/
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 code
int 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




// Java program to find path length
// having maximum number of bends
import 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 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
*/
  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);
 
    System.out.print(findMaxBends(root) - 1);
  }
}
 
// This code is contributed by Rajput-Ji

Python3




# Python3 program to find path Length
# having maximum number of bends
 
# Utility function to create a new node
class 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 code
if __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#




// C# program to find path length
// having maximum number of bends
using 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 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
*/
  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

Javascript




<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

 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :