使用Python查找二叉树中最长连续路径的长度

假设我们有一棵二叉树，我们需要找到其中最长的路径。

因此，如果输入如下：

那么输出将是5，因为最长连续序列是[2, 3, 4, 5, 6]。

为了解决这个问题，我们将采取以下步骤 −

如果根为空，则
- 返回0
maxPath := 0
定义一个名为helper()的函数。这将接受节点。
inc := 1，dec := 1
如果节点的左侧不为空，则
- [left_inc，left_dec]：= helper（节点的左侧）
否则，
- [left_inc，left_dec]：= [0，0]
如果节点的右侧不为空，则
- [right_inc，right_dec]：= helper（节点的右侧）
否则，
- [right_inc，right_dec]：= [0，0]
如果节点的左侧不为空，且节点的值减去左侧节点的值与1相同，则
- inc：=最大值，使inc和（left_inc +1）
否则，当节点的左侧不为空且节点的值减去左侧节点的值与-1相同时，则
- dec：=最大值，使dec和（left_dec +1）
如果节点的右侧不为空，并且节点的值减去右侧节点的值与1相同，则
- inc：=最大值，使inc和（right_inc +1）
否则，当节点的左侧节点不为空且右侧节点不为空，且左侧节点的值减去节点的值与1相同，右侧节点的值减去节点的值也与1相同时
- maxPath：=最大值，使maxPath和（left_dec + right_inc +1）
否则，当节点的左侧节点不为空且右侧节点不为空，且左侧节点的值减去节点的值与-1相同时
- maxPath：=最大值，使maxPath和（left_inc + right_dec +1）
maxPath：=最大值，使maxPath、inc和dec
返回inc、dec
从主方法执行以下操作：
helper(root)
返回maxPath

让我们看一下以下实现，以获得更好的理解 −

更多Python相关文章，请阅读：Python 教程

实例

class TreeNode：
   def __init__(self, data, left = None, right = None)：
      self.val = data
      self.left = left
      self.right = right
     
def print_tree(root)：
   if root is not None：
      print_tree(root.left)
      print(root.val, end = ', ')
      print_tree(root.right)

class Solution：
   def solve(self, root)：
      if not root：
         return 0
      self.maxPath = 0

      def helper(node)：
         inc, dec = 1, 1
         if node.left：
            left_inc, left_dec = helper(node.left)
         else：
            left_inc, left_dec = 0, 0
         if node.right：
            right_inc, right_dec = helper(node.right)
         else：
            right_inc, right_dec = 0, 0

         if node.left and node.val - node.left.val == 1：
            inc = max(inc, left_inc + 1)
         elif node.left and node.val - node.left.val == -1：
            dec = max(dec, left_dec + 1)

         if node.right and node.val - node.right.val == 1：
            inc = max(inc, right_inc + 1)
         elif node.right and node.val - node.right.val == -1：
            dec = max(dec, right_dec + 1)

         if (node.left and node.right and node.left.val - node.val == 1 and node.val - node.right.val == 1)：
            self.maxPath = max(self.maxPath, left_dec + right_inc + 1)
         elif (node.left and node.right and node.left.val - node.val == -1
            and node.val - node.right.val == -1)：
            self.maxPath = max(self.maxPath, left_inc + right_dec + 1)
           
         self.maxPath = max(self.maxPath, inc, dec)
         return inc, dec

      helper(root)
      return self.maxPath
     
ob = Solution()
root = TreeNode(3)
root.left = TreeNode(2)
root.right = TreeNode(4)
root.right.left = TreeNode(5)
root.right.right = TreeNode(9)
root.right.left.left = TreeNode(6)
print(ob.solve(root))

输入

root = TreeNode(3)
root.left = TreeNode(2)
root.right = TreeNode(4)
root.right.left = TreeNode(5)
root.right.right = TreeNode(9)
root.right.left.left = TreeNode(6)