# Binary Tree Longest Consecutive Sequence II in C++

Suppose we have a binary tree; we have to find the length of the Longest Consecutive Path in that Binary Tree. Here the path can be either increasing or decreasing. So as an example [1,2,3,4] and [4,3,2,1] are both considered as a valid path, but the path [1,2,4,3] is not a valid one.

Otherwise, the path can be in the child-Parent-child sequence, where not necessarily be parent-child order.

So, if the input is like then the output will be 3 as the longest consecutive path will be like [1, 2, 3] or [3, 2, 1].

To solve this, we will follow these steps −

• Define a function solveUtil(), this will take node,

• if the node is null, then −

• return { 0, 0 }

• left = solveUtil(left of node)

• left = solveUtil(right of node)

• Define one pair temp := {1,1}

• if left of node is present and value of left of node is same as value of node + 1, then −

• temp.first := maximum of temp.first and 1 + left.first

• ans := maximum of ans and temp.first

• if right of node is present and value of right of node is same as value of node + 1, then −

• temp.first := maximum of temp.first and 1 + right.first

• ans := maximum of ans and temp.first

• if left of node is present and value of left of node is same as value of node - 1, then −

• temp.second := maximum of temp.second and 1 + left.second

• ans := maximum of ans and temp.second

• if right of node is present and value of right of node is same as value of node - 1, then −

• temp.second := maximum of temp.second and 1 + right.second

• ans := maximum of ans and temp.second

• ans := maximum of { ans and temp.first + temp.second - 1 }

• return temp

• From the main method do the following −

• ans := 0

• solveUtil(root)

• return ans

## Example

Let us see the following implementation to get a better understanding −

Live Demo

#include <bits/stdc++.h>
using namespace std;
class TreeNode{
public:
int val;
TreeNode *left, *right;
TreeNode(int data){
val = data;
left = NULL;
right = NULL;
}
};
class Solution {
public:
int ans = 0;
pair<int, int> solveUtil(TreeNode* node){
if (!node) {
return { 0, 0 };
}
pair<int, int> left = solveUtil(node->left);
pair<int, int> right = solveUtil(node->right);
pair<int, int> temp = { 1, 1 };
if (node->left && node->left->val == node->val + 1) {
temp.first = max(temp.first, 1 + left.first);
ans = max(ans, temp.first);
}
if (node->right && node->right->val == node->val + 1) {
temp.first = max(temp.first, 1 + right.first);
ans = max(ans, temp.first);
}
if (node->left && node->left->val == node->val - 1) {
temp.second = max(temp.second, 1 + left.second);
ans = max(ans, temp.second);
}
if (node->right && node->right->val == node->val - 1) {
temp.second = max(temp.second, 1 + right.second);
ans = max(ans, temp.second);
}
ans = max({ ans, temp.first + temp.second - 1 });
return temp;
}
int longestConsecutive(TreeNode* root){
ans = 0;
solveUtil(root);
return ans;
}
};
main(){
Solution ob;
TreeNode *root = new TreeNode(2);
root->left = new TreeNode(1);
root->right = new TreeNode(3);
cout << (ob.longestConsecutive(root));
}

## Input

TreeNode *root = new TreeNode(2);
root->left = new TreeNode(1);
root->right = new TreeNode(3);

## Output

3