# [LeetCode] 298. Binary Tree Longest Consecutive Sequence 二叉树最长连续序列

2021年09月15日 阅读数：2

Given a binary tree, find the length of the longest consecutive sequence path.html

The path refers to any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The longest consecutive path need to be from parent to child (cannot be the reverse).java

For example,node

```   1
\
3
/ \
2   4
\
5
```

Longest consecutive sequence path is `3-4-5`, so return `3`.python

```   2
\
3
/
2
/
1
```

Longest consecutive sequence path is `2-3`,not`3-2-1`, so return `2`.函数

Java: Time Complexity - O(n)，  Space Complexity - O(n)spa

```/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Solution {
private int maxLen = 0;

public int longestConsecutive(TreeNode root) {
longestConsecutive(root, 0, 0);
return maxLen;
}

private void longestConsecutive(TreeNode root, int lastVal, int curLen) {
if (root == null) return;
if (root.val != lastVal + 1) curLen = 1;
else curLen++;
maxLen = Math.max(maxLen, curLen);
longestConsecutive(root.left, root.val, curLen);
longestConsecutive(root.right, root.val, curLen);
}
}
```

Python:code

```class Solution(object):
def longestConsecutive(self, root):
"""
:type root: TreeNode
:rtype: int
"""
self.max_len = 0

def longestConsecutiveHelper(root):
if not root:
return 0

left_len = longestConsecutiveHelper(root.left)
right_len = longestConsecutiveHelper(root.right)

cur_len = 1
if root.left and root.left.val == root.val + 1:
cur_len = max(cur_len, left_len + 1);
if root.right and root.right.val == root.val + 1:
cur_len = max(cur_len, right_len + 1)

self.max_len = max(self.max_len, cur_len, left_len, right_len)

return cur_len

longestConsecutiveHelper(root)
return self.max_len
```

C++:htm

```class Solution {
public:
int longestConsecutive(TreeNode* root) {
if (!root) return 0;
int res = 0;
dfs(root, root->val, 0, res);
return res;
}
void dfs(TreeNode *root, int v, int out, int &res) {
if (!root) return;
if (root->val == v + 1) ++out;
else out = 1;
res = max(res, out);
dfs(root->left, root->val, out, res);
dfs(root->right, root->val, out, res);
}
};
```

C++:

```class Solution {
public:
int longestConsecutive(TreeNode* root) {
if (!root) return 0;
int res = 0;
dfs(root, 1, res);
return res;
}
void dfs(TreeNode *root, int len, int &res) {
res = max(res, len);
if (root->left) {
if (root->left->val == root->val + 1) dfs(root->left, len + 1, res);
else dfs(root->left, 1, res);
}
if (root->right) {
if (root->right->val == root->val + 1) dfs(root->right, len + 1, res);
else dfs(root->right, 1, res);
}
}
};
```

C++:

```class Solution {
public:
int longestConsecutive(TreeNode* root) {
return helper(root, NULL, 0);
}
int helper(TreeNode *root, TreeNode *p, int res) {
if (!root) return res;
res = (p && root->val == p->val + 1) ? res + 1 : 1;
return max(res, max(helper(root->left, root, res), helper(root->right, root, res)));
}
};
```

C++: 迭代

```class Solution {
public:
int longestConsecutive(TreeNode* root) {
if (!root) return 0;
int res = 0;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
int len = 1;
TreeNode *t = q.front(); q.pop();
while ((t->left && t->left->val == t->val + 1) || (t->right && t->right->val == t->val + 1)) {
if (t->left && t->left->val == t->val + 1) {
if (t->right) q.push(t->right);
t = t->left;
} else if (t->right && t->right->val == t->val + 1) {
if (t->left) q.push(t->left);
t = t->right;
}
++len;
}
if (t->left) q.push(t->left);
if (t->right) q.push(t->right);
res = max(res, len);
}
return res;
}
};
```

[LeetCode] 128. Longest Consecutive Sequence 求最长连续序列

[LeetCode] 300. Longest Increasing Subsequence 最长递增子序列

[LeetCode] 549. Binary Tree Longest Consecutive Sequence II 二叉树最长连续序列 II

[LintCode] 619 Binary Tree Longest Consecutive Sequence III 二叉树最长连续序列 III