Leetcode_树

整理了一下LeetCode中比较热门的一些与树相关的题。
首先是树的遍历以及求树的深度的题目：
144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
102.二叉树的层次遍历
104. 二叉树的最大深度
111. 二叉树的最小深度
然后是二叉搜索树的一些相关题目：
95.不同的二叉搜索树
96. 不同的二叉搜索树
98. 验证二叉搜索树
108. 将有序数组转换为二叉搜索树
230. 二叉搜索树中第K小的元素
235.二叉搜索树的最近公共祖先
538. 把二叉搜索树转换为累加树
最后是一些不知道怎么分类的题。。。
（树的题目大部分可以用递归来解，因为树本身定义的时候就是用递归定义的。）
101. 对称二叉树
155. 最小栈
103. 二叉树的锯齿形层次遍历
116. 填充每个节点的下一个右侧节点指针
236. 二叉树的最近公共祖先
297. 二叉树的序列化与反序列化
124. 二叉树中的最大路径和
114. 二叉树展开为链表
226. 翻转二叉树
337. 打家劫舍 III
437. 路径总和 III
543.二叉树的直径
617. 合并二叉树
100.相同的树
以及LeetCode上一些出现频率比较高的题目（这里只记录频率最高的前八题）

199. 二叉树的右视图
863. 二叉树中所有距离为 K 的结点

144. 二叉树的前序遍历

题目描述：给定一个二叉树，返回它的 前序 遍历。

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

递归代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def helppre(root):
            if not root:return
            res.append(root.val)
            helppre(root.left)
            helppre(root.right)
        helppre(root)
        return res

迭代代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:return []
        stack=[root]
        res=[]
        while stack:
            tmp=stack.pop()
            if tmp.right:stack.append(tmp.right)
            if tmp.left:stack.append(tmp.left)
            res.append(tmp.val)
        return res

94. 二叉树的中序遍历

题目描述：给定一个二叉树，返回它的中序 遍历。

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

递归代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        L=[]
        def helpin(root):
            if not root:return
            helpin(root.left)
            L.append(root.val)
            helpin(root.right)
        helpin(root)
        return L

迭代代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        p=root
        res=[]
        stack=[]
        while p or stack:
            while p:
                stack.append(p)
                p=p.left
            tmp=stack.pop()
            res.append(tmp.val)
            p=tmp.right
        return res

145. 二叉树的后序遍历

题目描述：给定一个二叉树，返回它的 后序 遍历。

进阶: 递归算法很简单，你可以通过迭代算法完成吗？
递归代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        res=[]
        def helppost(root):
            if not root:return
            helppost(root.left)
            helppost(root.right)
            res.append(root.val)
        helppost(root)
        return res

迭代代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:return []
        stack1=[root]
        stack2=[]
        res=[]
        while stack1:
            tmp=stack1.pop()
            stack2.append(tmp.val)
            if tmp.left:stack1.append(tmp.left)
            if tmp.right:stack1.append(tmp.right)
        while stack2:
            temp=stack2.pop()
            res.append(temp)
        return res

102.二叉树的层次遍历

题目描述：给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

代码：
递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:return []
        levels=[]
        def helper(root,level):
            if len(levels)==level:
                levels.append([])
            levels[level].append(root.val)
            if root.left:
                helper(root.left,level+1)
            if root.right:
                helper(root.right,level+1)
        helper(root,0)
        return levels

迭代

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from collections import deque
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:return []
        levels=[]
        level=0
        queue=deque([root,])
        while queue:
            length=len(queue)
            levels.append([])
            for i in range(length):
                node=queue.popleft()
                levels[level].append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            level+=1
        return levels

104. 二叉树的最大深度

题目描述：给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

代码：
递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        depth=0
        if not root:return depth
        depth+=1
        depth+=max(self.maxDepth(root.left),self.maxDepth(root.right))
        return depth

迭代

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        stack=[]
        depth=0
        if root:
            stack.append((1,root))
        while stack:
            cur_depth,root=stack.pop()
            if root:
                depth=max(depth,cur_depth)
                stack.append((cur_depth+1,root.left))
                stack.append((cur_depth+1,root.right))
        return depth

111. 二叉树的最小深度

题目描述：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。

代码：
递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:return 0
        child=[root.left,root.right]
        if not any(child):
            return 1
        min_depth=float('inf')
        for x in child:
            if x:
                min_depth=min(self.minDepth(x),min_depth)
        return min_depth+1

95.不同的二叉搜索树

题目描述：给定一个整数 n，生成所有由 1 … n 为节点所组成的二叉搜索树。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def generateTrees(self, n):
        """
        :type n: int
        :rtype: List[TreeNode]
        """
        if n==0:return None
        def helper(start,end):
            res=[]
            if start>end:res.append(None)
            for val in range(start,end+1):
                for left in helper(start,val-1):
                    for right in helper(val+1,end):
                        root=ListNode(val)
                        root.left=left
                        root.right=right
                        res.append(root)
            return res
        
        return helper(1,n)

96. 不同的二叉搜索树

题目描述：给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？


代码：

class Solution(object):
    def numTrees(self, n):
        """
        :type n: int
        :rtype: int
        """
        dp=[0]*(n+1)
        dp[0]=1
        dp[1]=1
        for i in range(2,n+1):
            for j in range(i):
                dp[i]+=dp[j]*dp[i-j-1]
        return dp[-1]
    
    

      

98. 验证二叉搜索树

题目描述：给定一个二叉树，判断其是否是一个有效的二叉搜索树。假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:return True
        res=[]
        def helper(root):
            if not root:return
            helper(root.left)
            res.append(root.val)
            helper(root.right)
        helper(root)
        return res==sorted(res) and len(set(res))==len(res)

100.相同的树

题目描述：给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。


代码：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if p==None and q==None:return True
        if p==None and q!=None:return False
        if p!=None and q==None:return False
        if p.val!=q.val:return False
        l=self.isSameTree(p.left,q.left)
        r=self.isSameTree(p.right,q.right)
        return l and r

101. 对称二叉树

题目描述：给定一个二叉树，检查它是否是镜像对称的。例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def match(l,r):
            if not l and not r:return True
            if not l or not r:return False
            return l.val==r.val and match(l.left,r.right) and match(l.right,r.left)
        return match(root,root)

108. 将有序数组转换为二叉搜索树

题目描述：将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if not nums or len(nums)==0:
            return None
        length=len(nums)
        left=0
        right=length-1
        mid=(left+right)/2
        root=TreeNode(nums[mid])
        root.left=self.sortedArrayToBST(nums[0:mid])
        root.right=self.sortedArrayToBST(nums[mid+1:])
        return root

155. 最小栈

**题目描述**： 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) -- 将元素 x 推入栈中。 pop() -- 删除栈顶的元素。 top() -- 获取栈顶元素。 getMin() -- 检索栈中的最小元素。 

代码：

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack=[]
        self.mindata=[]
        self.minnumber=float('inf')
        self.mindata=[]

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.stack.append(x)
        if self.mindata==[] or self.mindata[-1]>=x:
            self.mindata.append(x)

    def pop(self):
        """
        :rtype: None
        """
        top=self.stack.pop()
        if top==self.mindata[-1]:
            self.mindata.pop()
        return top

    def top(self):
        """
        :rtype: int
        """
        return self.stack[-1]

    def getMin(self):
        """
        :rtype: int
        """
        return self.mindata[-1]
        


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack=[]
        self.minnumber=float('inf')
        self.mindata=[self.minnumber]
    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.stack.append(x)
        self.minnumber=min(self.mindata[-1],x)
        self.mindata.append(self.minnumber)

    def pop(self):
        """
        :rtype: None
        """
        self.mindata.pop()
        return self.stack.pop()

    def top(self):
        """
        :rtype: int
        """
        return self.stack[-1]

    def getMin(self):
        """
        :rtype: int
        """
        return self.mindata[-1]
        
        


# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

230. 二叉搜索树中第K小的元素

题目描述：给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。
说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。
思路：中序遍历+提前终止
代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        if not root:return None
        inorder_list=[]
        def helpin(root,k):
            i=0
            stack=[]
            res=[]
            T=root
            while (T or stack) and i<k:
                while T:
                    stack.append(T)
                    T=T.left
                tmp=stack.pop()
                res.append(tmp.val)
                i+=1
                T=tmp.right
            return res
        inorder_list=helpin(root,k)
        return inorder_list[-1]
        

103. 二叉树的锯齿形层次遍历

题目描述：
思路：我的想法是先正常层次遍历，然后把其中的部分翻转（应该还能改进，我的空间复杂度好像比较高）
代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

from collections import deque
class Solution(object):
    def zigzagLevelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:return []
        levels=[]
        def helplevels(root):
            levels=[]
            level=0
            queue=deque([root,])
            while queue:
                length=len(queue)
                levels.append([])
                for i in range(length):
                    tmp=queue.popleft()
                    levels[level].append(tmp.val)
                    if tmp.left:queue.append(tmp.left)
                    if tmp.right:queue.append(tmp.right)
                level+=1
            return levels
        levels=helplevels(root)
        length=len(levels)
        for i in range(length):
            if i%2:levels[i].reverse()
        return levels
            

116. 填充每个节点的下一个右侧节点指针

题目描述：给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
代码：

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val, left, right, next):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
from collections import deque
class Solution(object):
    def connect(self, root):
        """
        :type root: Node
        :rtype: Node
        """
        if not root:return None
        def helplevels(root):
            queue=deque([root,])
            levels=[]
            level=0
            while queue:
                levels.append([])
                length=len(queue)
                for i in range(length):
                    tmp=queue.popleft()
                    levels[level].append(tmp)
                    if tmp.left:queue.append(tmp.left)
                    if tmp.right:queue.append(tmp.right)
                level+=1
            return levels
        levels=helplevels(root)
        l=len(levels)
        for i in range(l):
            lens=len(levels[i])
            for j in range(lens-1):
                levels[i][j].next=levels[i][j+1]
        return root
        

235.二叉搜索树的最近公共祖先

题目描述：定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]


思路：二叉搜索树本身有序，所以只要当查找p和q的过程中开始分支，那么当前子树根节点就是我们要的节点。
代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        p_val=p.val
        q_val=q.val
        T=root
        while T:
            parent_val=T.val
            if parent_val<p_val and parent_val<q_val:
                T=T.right
            elif parent_val>p_val and parent_val>q_val:
                T=T.left
            else:
                return T
        

236. 二叉树的最近公共祖先

题目描述：给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”


思路：首先在二叉树中搜索给定的节点 pp 和 qq，然后找到它们的最近共同祖先。我们可以使用普通的树遍历来搜索这两个节点。一旦我们达到所需的节点 pp 和 qq，我们就可以回溯并找到最近的共同祖先。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.res=None
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        def recurse(root):
            if not root:return False
            mid=(root==p or root==q)
            left=recurse(root.left)
            right=recurse(root.right)
            if mid+left+right>=2:
                self.res=root
            return mid or left or right
        recurse(root)
        return self.res

297. 二叉树的序列化与反序列化

题目描述：序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
示例:

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        def myserialize(root,string):
            if not root:
                string += 'None,'
            else:
                string+=str(root.val)+','
                string=myserialize(root.left,string)
                string=myserialize(root.right,string)
            return string
        return myserialize(root, '')
    
    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        def mydeserialize(l):
            if l[0]=='None':
                l.pop(0)
                return None
            root=TreeNode(l[0])
            l.pop(0)
            root.left=mydeserialize(l)
            root.right=mydeserialize(l)
            return root
        data_list=data.split(',')
        root=mydeserialize(data_list)
        return root

    
    
# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

124. 二叉树中的最大路径和

题目描述：给定一个非空二叉树，返回其最大路径和。
本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def maxPathSum(self, root):
        self.max_sum=float('-inf')
        self.max_Path(root)
        return self.max_sum
        """
        :type root: TreeNode
        :rtype: int
        """
    def max_Path(self,root):
        if not root:return 0
        left=self.max_Path(root.left)
        right=self.max_Path(root.right)
        self.max_sum=max(left+right+root.val,self.max_sum)
        tmp=max(left,right)+root.val
        return tmp if tmp>0 else 0

114. 二叉树展开为链表

题目描述：给定一个二叉树，原地将它展开为链表。
例如，给定二叉树

将其展开为：

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def flatten(self, root):
        """
        :type root: TreeNode
        :rtype: None Do not return anything, modify root in-place instead.
        """
        if not root:return None
        l=self.flatten(root.left)
        r=self.flatten(root.right)
        root.left=None
        root.right=l
        tmp=root
        while tmp.right:
            tmp=tmp.right
        tmp.right=r
        return root

226. 翻转二叉树

题目描述：翻转一棵二叉树。
示例：
输入：

输出：

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:return None
        root.left,root.right=root.right,root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

337. 打家劫舍 III

题目描述;在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
示例 1:

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def rob(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:return 0
        return max(self.max_sum(root))
    def max_sum(self,root):
        cur=root
        if not cur:return [0,0]
        l=self.max_sum(root.left)
        r=self.max_sum(root.right)
        return [max(l)+max(r),cur.val+l[0]+r[0]] 
    #返回第一个元素是不包含当前节点的值，第二项包含当前节点的值。
    

437. 路径总和 III

**题目描述**：给定一个二叉树，它的每个结点都存放着一个整数值。 找出路径和等于给定数值的路径总数。 路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。 二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。  **代码**：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: int
        """
        if not root:
            return 0
        def helper(root,sums):
            count=0
            if not root:
                return 0
            if root.val==sums:
                count+=1
            count+=helper(root.left,sums-root.val)
            count+=helper(root.right,sums-root.val)
            return count
        return helper(root,sum)+self.pathSum(root.left,sum)+self.pathSum(root.right,sum)
            

538. 把二叉搜索树转换为累加树

题目描述：给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

思路：先遍历右子树，遍历过程中把遇到的每个值都加起来，然后保存根节点，然后遍历左子树
代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        self.sums=0
        def dfs(root):
            if not root:return root
            dfs(root.right)
            self.sums+=root.val
            root.val=self.sums
            dfs(root.left)
            return root
        return dfs(root)

543.二叉树的直径

题目描述：给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过根结点。
示例 :
给定二叉树

返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。
注意：两结点之间的路径长度是以它们之间边的数目表示。
代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def diameterOfBinaryTree(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def dfs(root):
            if not root:return 0
            l=dfs(root.left)
            r=dfs(root.right)
            self.R=max(l+r,self.R)
            return max(l,r)+1
        self.R=0
        dfs(root)
        return self.R
   

617. 合并二叉树

题目描述：给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
示例 1:

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def mergeTrees(self, t1, t2):
        """
        :type t1: TreeNode
        :type t2: TreeNode
        :rtype: TreeNode
        """
        if not t1 and not t2:
            return None 
        if not t1:
            return t2
        if not t2:
            return t1
        t_val=t1.val+t2.val
        T=TreeNode(t_val)
        T.left=self.mergeTrees(t1.left,t2.left)
        T.right=self.mergeTrees(t1.right,t2.right)
        return T

199. 二叉树的右视图

题目描述：给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

思路：先层次遍历然后取每一层最右边的一个数
代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from collections import deque
class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:return []
        def levelorder(root):
            levels=[]
            level=0
            T=root
            queue=deque([root,])
            while queue:
                length=len(queue)
                levels.append([])
                for i in range(length):
                    tmp=queue.popleft()
                    levels[level].append(tmp.val)
                    if tmp.left:queue.append(tmp.left)
                    if tmp.right:queue.append(tmp.right)
                level+=1
            return levels
        levels=levelorder(root)
        lens=len(levels)
        res=[]
        for i in range(lens):
            res.append(levels[i][-1])
        return res
            

863. 二叉树中所有距离为 K 的结点

题目描述：给定一个二叉树（具有根结点 root）， 一个目标结点 target ，和一个整数值 K 。
返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。


思路：前序遍历，哈希各个节点的深度和父节点集合。
节点a与节点b的最近公共父节点为c，h为节点的深度，则a与b的距离为$h(a)+h(b)-2\ast h(c)$
依据这个公式再遍历一次树就可以了,满足条件的就输出

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def distanceK(self, root, target, K):
        h={}
        f={}
        def g(r,i,fs):
            if r:
                h[r.val]=i
                f[r.val]=[r.val]+fs     #让最近的父节点排在最前面
                g(r.left,i+1,f[r.val])
                g(r.right,i+1,f[r.val])
        g(root,0,[])

        ans=[]
        t=target.val
        for i in h:
            for common in f[t]:
                if common in f[i]:
                    if h[t]+h[i]-2*h[common]==K:
                        ans+=[i]
                    break

        return ans