LeetCode：Recursion

1. diameterOfBinaryTree

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


class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        def traverse(node):
            self.longest = 0
            if node is None:
                return 0
            print("--- node ---")
            left_len, right_len = traverse(node.left), traverse(node.right)
            left = left_len + 1 if node.left is not None else 0
            right = right_len + 1 if node.right is not None else 0
            self.longest = max(self.longest, left + right)
            return max(left, right) + 1
        traverse(root)
        return self.longest
def stringToTreeNode(input):
    input = input.strip()
    input = input[1:-1]
    if not input:
        return None

    inputValues = [s.strip() for s in input.split(',')]
    root = TreeNode(int(inputValues[0]))
    nodeQueue = [root]
    front = 0
    index = 1
    while index < len(inputValues):
        node = nodeQueue[front]
        front = front + 1
        item = inputValues[index]
        index = index + 1
        if item != "null":
            leftNumber = item
            node.left = TreeNode(leftNumber)
            nodeQueue.append(node.left)
        # 已经有root节点，所以等于的时候也可以break
        if index >= len(inputValues):
            break

        item = inputValues[index]
        index = index + 1
        if item != "null":
            rightNumber = item
            node.right = TreeNode(rightNumber)
            nodeQueue.append(node.right)
    return root

def intToString(input):
    if input is None:
        input = 0
    return str(input)

def main():
    import sys
    lines = input()
    root = stringToTreeNode(lines)
    ret = Solution().diameterOfBinaryTree(root)
    out = intToString(ret)
    print ('out: ',out)

if __name__ == '__main__':
    main()
    print('finish coding.')

2. longestUnivaluePath：参考了别人的代码，还需多练习思维能力

class Solution(object):
    # Given a binary tree, find the length of the longest path where
    # each node in the path has the same value.
    # This path may or may not pass through the root.
    # 1. 二叉树的最长路径，要求路径上每一个节点的值都是一样的。
    # 2. 这个路径可能不经过根节点
    # 结论：那么这样，这个二叉树要全部遍历完，最后返回最大的路径
    def longestUnivaluePath(self, data):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.longest = 0
        def traverse(node):
            if node == None:
                return 0
            left_len, right_len = traverse(node.left), traverse(node.right)
            left = (left_len + 1) if node.left and node.left.val == node.val else 0
            right = (right_len + 1) if node.right and node.right.val == node.val else 0
            self.longest = max(self.longest,left + right)
            return max(left, right)
        traverse(data)
        return self.longest