Binary tree creation & traversal

Hierarchy creation

Reference resources ：Python --- Sequence establishment of binary tree

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = None
        self.right = None

def creatTree(nodeList):
    if nodeList[0] == None:  return None
    head = TreeNode(nodeList[0])
    nodes = [head] #  Used to store nodes in the tree , Every time a node is generated, it is placed in the list , Save the root node here .
    j = 1  #  Create variables j be used for nodeList The index of the element in the , For the initial 1. Because the first 0 Elements have created root nodes .
    for node in nodes:  #  Take out one by one Nodes Nodes in the list , Create a left child node and a right child node 
        if node != None:
            node.left = (TreeNode(nodeList[j])) if nodeList[j] != None else None
            nodes.append(node.left) #  Add the new node Nodes Array , Make it for In the loop, you can continue to add child nodes 
            j += 1
            if j == len(nodeList): #  If the nodeList Equal values indicate that all nodes have been added , Go straight back to head The root node completes the establishment of the tree 
                return head
            
            node.right = (TreeNode(nodeList[j])) if nodeList[j] != None else None
            j += 1
            nodes.append(node.right)
            if j == len(nodeList):
                return head
a = [1,2,3,4,None,6,7]
a = creatTree(a)

#  Use ： Return the longest path of binary tree ,Leecode 124
class Solution:
    def __init__(self):
        self.maxSum = float("-inf")
    def maxPathSum(self, root: TreeNode) -> int:
        def maxGain(node):
            if not node:
                return 0
            leftGain = max(maxGain(node.left), 0)
            rightGain = max(maxGain(node.right), 0)
         
            priceNewpath = node.val + leftGain + rightGain

            self.maxSum = max(self.maxSum, priceNewpath)
            return node.val + max(leftGain, rightGain)
        maxGain(root)
        return self.maxSum

s = Solution()
s.maxPathSum(a)

Continue......