zoukankan      html  css  js  c++  java
  • [LeetCode] 298. Binary Tree Longest Consecutive Sequence 二叉树最长连续序列

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

    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).

    For example,

       1
        
         3
        / 
       2   4
            
             5
    

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

       2
        
         3
        / 
       2    
      / 
     1
    

    Longest consecutive sequence path is 2-3,not3-2-1, so return 2.

    求二叉树的最长连续序列的长度,要从父节点到子节点。最长连续子序列必须是从root到leaf的方向。 比如 1->2,返回长度2, 比如1->3->4->5,返回3->4->5这个子序列的长度3。

    解法:递归遍历binary tree,递归函数传入父节点的值,以帮助子节点判断是否连续。

    Java: Time Complexity - O(n),  Space Complexity - O(n)

    /**
     * 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:

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

    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

    All LeetCode Questions List 题目汇总

  • 相关阅读:
    JAVA NIO
    Spider、xmlSpider、FeedSpider、CrawlSpider、RedisSpider分别作用
    Scrapy中xpath用到中文报错
    xpath无法匹配tbody标签
    读书-《不凶不吼教出好孩子》-管教孩子应该先管好自己
    Markdown基本语法
    读书-《刻意练习》天才与庸才的距离
    读书-《第一次买保险就买对》保险我们这样买
    读书-《断舍离》做减法来生活
    读书-《富爸爸穷爸爸》的财商教育经
  • 原文地址:https://www.cnblogs.com/lightwindy/p/8692384.html
Copyright © 2011-2022 走看看