Maximum Consecutive Increasing Path Length in Binary Tree - GeeksforGeeks

04 Mar, 2022
Given a Binary Tree find the length of the longest path which comprises of nodes with consecutive values in increasing order. Every node is considered as a path of length 1. Examples:  
       10
      /    \     
     /      \
    11        9    
   / \        /\
  /   \      /  \
13    12    13   8
Maximum Consecutive Path Length is 3 (10, 11, 12)
Note: 10, 9 ,8 is NOT considered since
the nodes should be in increasing order.

        5
          /  \
         /    \
        8      11
        /        \
       /          \
       9      10   
      /              /
     /             /
    6           15
Maximum Consecutive Path Length is 2 (8, 9).
 
Every node in the Binary Tree can either become part of the path which is starting from one of its parent node or a new path can start from this node itself. The key is to recursively find the path length for the left and right sub tree and then return the maximum. Some cases need to be considered while traversing the tree which are discussed below.prev : stores the value of the parent node. Initialize prev with one less than value of root node so that the path starting at root can be of length at least 1. len : Stores the path length which ends at the parent of currently visited node.Case 1: Value of Current Node is prev +1 In this case increase the path length by 1, and then recursively find the path length for the left and the right sub tree then return the maximum between two lengths.Case 2: Value of Current Node is NOT prev+1 A new path can start from this node, so recursively find the path length for the left and the right sub tree. The path which ends at the parent node of current node might be greater than the path which starts from this node.So take the maximum of the path which starts from this node and which ends at previous node.Below is the implementation of above idea. 
C++
Java
Python3
C#
Javascript
// C++ Program to find Maximum Consecutive// Path Length in a Binary Tree#include <bits/stdc++.h>using namespace std; // To represent a node of a Binary Treestruct Node{    Node *left, *right;    int val;}; // Create a new Node and return its addressNode *newNode(int val){    Node *temp = new Node();    temp->val = val;    temp->left = temp->right = NULL;    return temp;} // Returns the maximum consecutive Path Lengthint maxPathLenUtil(Node *root, int prev_val, int prev_len){    if (!root)        return prev_len;     // Get the value of Current Node    // The value of the current node will be    // prev Node for its left and right children    int cur_val = root->val;     // If current node has to be a part of the    // consecutive path then it should be 1 greater    // than the value of the previous node    if (cur_val == prev_val+1)    {         // a) Find the length of the Left Path        // b) Find the length of the Right Path        // Return the maximum of Left path and Right path        return max(maxPathLenUtil(root->left, cur_val, prev_len+1),                   maxPathLenUtil(root->right, cur_val, prev_len+1));    }     // Find length of the maximum path under subtree rooted with this    // node (The path may or may not include this node)    int newPathLen = max(maxPathLenUtil(root->left, cur_val, 1),                         maxPathLenUtil(root->right, cur_val, 1));     // Take the maximum previous path and path under subtree rooted    // with this node.    return  max(prev_len, newPathLen);} // A wrapper over maxPathLenUtil().int maxConsecutivePathLength(Node *root){    // Return 0 if root is NULL    if (root == NULL)        return 0;     // Else compute Maximum Consecutive Increasing Path    // Length using maxPathLenUtil.    return maxPathLenUtil(root, root->val-1, 0);} //Driver program to test above functionint main(){    Node *root = newNode(10);    root->left = newNode(11);    root->right = newNode(9);    root->left->left = newNode(13);    root->left->right = newNode(12);    root->right->left = newNode(13);    root->right->right = newNode(8);     cout << "Maximum Consecutive Increasing Path Length is "         << maxConsecutivePathLength(root);     return 0;}
// Java Program to find Maximum Consecutive// Path Length in a Binary Treeimport java.util.*;class GfG { // To represent a node of a Binary Treestatic class Node{    Node left, right;    int val;} // Create a new Node and return its addressstatic Node newNode(int val){    Node temp = new Node();    temp.val = val;    temp.left = null;    temp.right = null;    return temp;} // Returns the maximum consecutive Path Lengthstatic int maxPathLenUtil(Node root, int prev_val, int prev_len){    if (root == null)        return prev_len;     // Get the value of Current Node    // The value of the current node will be    // prev Node for its left and right children    int cur_val = root.val;     // If current node has to be a part of the    // consecutive path then it should be 1 greater    // than the value of the previous node    if (cur_val == prev_val+1)    {         // a) Find the length of the Left Path        // b) Find the length of the Right Path        // Return the maximum of Left path and Right path        return Math.max(maxPathLenUtil(root.left, cur_val, prev_len+1),                maxPathLenUtil(root.right, cur_val, prev_len+1));    }     // Find length of the maximum path under subtree rooted with this    // node (The path may or may not include this node)    int newPathLen = Math.max(maxPathLenUtil(root.left, cur_val, 1),                        maxPathLenUtil(root.right, cur_val, 1));     // Take the maximum previous path and path under subtree rooted    // with this node.    return Math.max(prev_len, newPathLen);} // A wrapper over maxPathLenUtil().static int maxConsecutivePathLength(Node root){    // Return 0 if root is NULL    if (root == null)        return 0;     // Else compute Maximum Consecutive Increasing Path    // Length using maxPathLenUtil.    return maxPathLenUtil(root, root.val-1, 0);} //Driver program to test above functionpublic static void main(String[] args){    Node root = newNode(10);    root.left = newNode(11);    root.right = newNode(9);    root.left.left = newNode(13);    root.left.right = newNode(12);    root.right.left = newNode(13);    root.right.right = newNode(8);     System.out.println("Maximum Consecutive Increasing Path Length is "+maxConsecutivePathLength(root)); }}
# Python program to find Maximum consecutive# path length in binary tree # A binary tree nodeclass Node:         # Constructor to create a new node    def __init__(self, val):        self.val = val        self.left = None        self.right = None # Returns the maximum consecutive path lengthdef maxPathLenUtil(root, prev_val, prev_len):    if root is None:        return prev_len     # Get the value of current node    # The value of the current node will be    # prev node for its left and right children    curr_val =  root.val         # If current node has to be a part of the    # consecutive path then it should be 1 greater    # than the value of the previous node    if curr_val == prev_val +1 :                 # a) Find the length of the left path        # b) Find the length of the right path        # Return the maximum of left path and right path        return max(maxPathLenUtil(root.left, curr_val, prev_len+1),                   maxPathLenUtil(root.right, curr_val, prev_len+1))     # Find the length of the maximum path under subtree    # rooted with this node    newPathLen = max(maxPathLenUtil(root.left, curr_val, 1),                    maxPathLenUtil(root.right, curr_val, 1))     # Take the maximum previous path and path under subtree    # rooted with this node    return max(prev_len , newPathLen) # A Wrapper over maxPathLenUtil()def maxConsecutivePathLength(root):         # Return 0 if root is None    if root is None:        return 0         # Else compute maximum consecutive increasing path    # length using maxPathLenUtil    return maxPathLenUtil(root, root.val -1 , 0) # Driver program to test above functionroot = Node(10)root.left = Node(11)root.right = Node(9)root.left.left = Node(13)root.left.right = Node(12)root.right.left = Node(13)root.right.right = Node(8) print ("Maximum Consecutive Increasing Path Length is",)print (maxConsecutivePathLength(root)) # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
// C# Program to find Maximum Consecutive// Path Length in a Binary Treeusing System; class GfG{     // To represent a node of a Binary Tree    class Node    {        public Node left, right;        public int val;    }     // Create a new Node and return its address    static Node newNode(int val)    {        Node temp = new Node();        temp.val = val;        temp.left = null;        temp.right = null;        return temp;    }     // Returns the maximum consecutive Path Length    static int maxPathLenUtil(Node root,                int prev_val, int prev_len)    {        if (root == null)            return prev_len;         // Get the value of Current Node        // The value of the current node will be        // prev Node for its left and right children        int cur_val = root.val;         // If current node has to be a part of the        // consecutive path then it should be 1 greater        // than the value of the previous node        if (cur_val == prev_val+1)        {             // a) Find the length of the Left Path            // b) Find the length of the Right Path            // Return the maximum of Left path and Right path            return Math.Max(maxPathLenUtil(root.left, cur_val, prev_len+1),                    maxPathLenUtil(root.right, cur_val, prev_len+1));        }         // Find length of the maximum path under subtree rooted with this        // node (The path may or may not include this node)        int newPathLen = Math.Max(maxPathLenUtil(root.left, cur_val, 1),                            maxPathLenUtil(root.right, cur_val, 1));         // Take the maximum previous path and path under subtree rooted        // with this node.        return Math.Max(prev_len, newPathLen);    }     // A wrapper over maxPathLenUtil().    static int maxConsecutivePathLength(Node root)    {        // Return 0 if root is NULL        if (root == null)            return 0;         // Else compute Maximum Consecutive Increasing Path        // Length using maxPathLenUtil.        return maxPathLenUtil(root, root.val - 1, 0);    }     // Driver code    public static void Main(String[] args)    {        Node root = newNode(10);        root.left = newNode(11);        root.right = newNode(9);        root.left.left = newNode(13);        root.left.right = newNode(12);        root.right.left = newNode(13);        root.right.right = newNode(8);         Console.WriteLine("Maximum Consecutive" +                        " Increasing Path Length is "+                            maxConsecutivePathLength(root));    }} // This code has been contributed by 29AjayKumar
<script>// Javascript Program to find Maximum Consecutive// Path Length in a Binary Tree // To represent a node of a Binary Treeclass Node{    constructor(val)    {        this.val = val;        this.left = this.right = null;    }} // Returns the maximum consecutive Path Lengthfunction maxPathLenUtil(root,prev_val,prev_len){    if (root == null)        return prev_len;       // Get the value of Current Node    // The value of the current node will be    // prev Node for its left and right children    let cur_val = root.val;       // If current node has to be a part of the    // consecutive path then it should be 1 greater    // than the value of the previous node    if (cur_val == prev_val+1)    {           // a) Find the length of the Left Path        // b) Find the length of the Right Path        // Return the maximum of Left path and Right path        return Math.max(maxPathLenUtil(root.left, cur_val, prev_len+1),                maxPathLenUtil(root.right, cur_val, prev_len+1));    }       // Find length of the maximum path under subtree rooted with this    // node (The path may or may not include this node)    let newPathLen = Math.max(maxPathLenUtil(root.left, cur_val, 1),                        maxPathLenUtil(root.right, cur_val, 1));       // Take the maximum previous path and path under subtree rooted    // with this node.    return Math.max(prev_len, newPathLen);} // A wrapper over maxPathLenUtil().function maxConsecutivePathLength(root){    // Return 0 if root is NULL    if (root == null)        return 0;       // Else compute Maximum Consecutive Increasing Path    // Length using maxPathLenUtil.    return maxPathLenUtil(root, root.val-1, 0);} // Driver program to test above functionlet root = new Node(10);root.left = new Node(11);root.right = new Node(9);root.left.left = new Node(13);root.left.right = new Node(12);root.right.left = new Node(13);root.right.right = new Node(8); document.write("Maximum Consecutive Increasing Path Length is "+maxConsecutivePathLength(root)+"<br>"); // This code is contributed by rag2127</script>
Output:  
Maximum Consecutive Increasing Path Length is 3
 
YouTubeGeeksforGeeks500K subscribersMaximum Consecutive Increasing Path Length in Binary Tree | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 4:35•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=yAKaC3XyXJ4" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article is contributed by Chirag Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@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. 
prerna saini
29AjayKumar
rag2127
surinderdawra388
amartyaghoshgfg
simmytarika5
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Decision Tree
Binary Tree | Set 2 (Properties)
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
Construct Tree from given Inorder and Preorder traversals
Introduction to Tree Data Structure
Expression Tree
Deletion in a Binary Tree
Binary Tree (Array implementation)
Inorder Tree Traversal without recursion and without stack!
BFS vs DFS for Binary Tree