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

    def maxDepth(root):""":type root: TreeNode:rtype: int"""if root:left=maxDepth(root.left)right=maxDepth(root.right)return 1+max(left,right)return 0  

def invertTree(self, root):if root:root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)return root

def invertTree(self, root):stack = [root]while stack:node = stack.pop()if node:node.left, node.right = node.right, node.leftstack += node.left, node.rightreturn root

class TreeNode:def __init__(self,root):self.val=rootself.left=Noneself.right=Noneclass Solution:def averageOfLevels(self, root):#root为TreeNode类型def computeSum(root,height,sumlist,countlist):if not root:return 0if height>=len(countlist):sumlist.append(0)countlist.append(0)sumlist[height]+=root.valcountlist[height]+=1computeSum(root.left,height+1,sumlist,countlist)computeSum(root.right,height+1，sumlist,countlist)sumlist=[]countlist=[]computeSum(root,0,sumlist,countlist)return [i/j if j!=0 else 0 for i,j in zip(sumlist,countlist)]

def BFS（root):if not root:return 0prev,res=[root],[]while prev:cur=[]#给结果添加当前层数prev的平均值，prev为当前所有的值val=sum([node.val for node in prev])/float(len(prev))res.append(val)#该循环主要是cur添加prev所有的左右子树，即cur为下一层所有的值while prev:node=prev.pop()if node.left:cur.append(node.left)if node.right:cur.append(node.right)#将当前层数变为下一层prev=cur        return res

def isSameTrees(p,q):if not p and not q:return True    elif p and not q or (q and not p):return Falseelse:if p.val!=q.val:return Falseelse:return isSameTrees(p.left,q.left) and isSameTrees(p.right,q.right)

def allPath(root):'''root为TreeNode类输出：['1->2->5','1->3']'''res=[]　　 strPre=''def helper(Tree,strPre):if Tree:strPre+=str(Tree.val)+'->'　　　　　　　　#若左右子树都为空的时候就把结果加入列表中if not Tree.left and not Tree.right:res.append(strPre[:-2])　　　　　　　　#否则递归将左右子树的路径加进来else:helper(Tree.left,strPre)helper(Tree.right,strPre)helper(root,strPre)return res

    def levelOrder(self, root):""":type root: TreeNode:rtype: List[List[int]]"""res=[]if not root:return []prev=[root]while prev:           temp=[node.val for node in prev]res.append(temp)cur=[]while prev:node=prev.pop(False)  if node.left:cur.append(node.left)                 if node.right:cur.append(node.right)prev=curreturn res

#反向层次遍历
# dfs recursively
def levelOrderBottom1(self, root):res = []self.dfs(root, 0, res)return resdef dfs(self, root, level, res):if root:if len(res) < level + 1:res.insert(0, [])res[-(level+1)].append(root.val)self.dfs(root.left, level+1, res)self.dfs(root.right, level+1, res)# dfs + stack
def levelOrderBottom2(self, root):stack = [(root, 0)]res = []while stack:node, level = stack.pop()if node:if len(res) < level+1:res.insert(0, [])res[-(level+1)].append(node.val)stack.append((node.right, level+1))stack.append((node.left, level+1))return res# bfs + queue
def levelOrderBottom(self, root):queue, res = collections.deque([(root, 0)]), []while queue:node, level = queue.popleft()if node:if len(res) < level+1:res.insert(0, [])res[-(level+1)].append(node.val)queue.append((node.left, level+1))queue.append((node.right, level+1))return res

# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):def sortedArrayToBST(self, nums):""":type nums: List[int]:rtype: TreeNode"""if not nums:return Nonek=len(nums)//2root=TreeNode(nums[k])root.left=self.sortedArrayToBST(nums[:k])root.right=self.sortedArrayToBST(nums[k+1:])return root

class Solution(object):   tilt=0def findTilt(self, root):   """:type root: TreeNode:rtype: int"""def helper(root):if not root:return 0left=helper(root.left)right=helper(root.right)self.tilt+=abs(left-right)return left+right+root.valhelper(root)return self.tilt 

class Solution(object):    sumval=0def convertBST(self, root):""":type root: TreeNode:rtype: TreeNode"""           if not root:return None       def helper(node):if node:helper(node.right)node.val+=self.sumvalself.sumval=node.valhelper(node.left)return noderoot=helper(root)return root

    def findSecondMinimumValue(self, root):""":type root: TreeNode:rtype: int"""if not root:return -1prev=[root]minVal=root.valsecondVal=float('inf')while prev:cur=[]while prev:node=prev.pop()if minVal<node.val and node.val<secondVal:secondVal=node.valif node.left:cur.append(node.left)if node.right:cur.append(node.right)prev=curreturn -1 if secondVal==float('inf') else secondVal

class Solution(object):def isBalanced(self, root):""":type root: TreeNode:rtype: bool"""if not root:return Truedef helper(root):if root:left=helper(root.left)right=helper(root.right)return 1+max(left,right)return 0prev=[root]while prev:cur=[]while prev:node=prev.pop()left=right=0if node.left:cur.append(node.left)left=helper(node.left)if node.right:cur.append(node.right)right=helper(node.right)if abs(left-right)>1:return Falseprev=curreturn True

    def isBalanced(self, root):""":type root: TreeNode:rtype: bool"""def helper(root):if not root:return 0left=helper(root.left)right=helper(root.right)if left==-1 or right==-1 or abs(left-right)>1:return -1return 1+max(left,right)res=helper(root)return False if res==-1 else True

class Solution(object):def pathSum(self, root, sum):""":type root: TreeNode:type sum: int:rtype: int"""     self.res=0def ans(root,cur,sum):cur+=root.valif cur==sum:self.res+=1if root.left:ans(root.left,cur,sum)if root.right:ans(root.right,cur,sum)def helper(root,sum):if root:ans(root,0,sum)if root.left:helper(root.left,sum)if root.right:helper(root.right,sum)helper(root,sum)return self.res

    def pathSum(self, root, sum):""":type root: TreeNode:type sum: int:rtype: List[List[int]]"""if not root:return []res=[]temp= []def helper(root,sum,temp,res):if root:# temp += str(root.val) + ','
                temp.append(root.val)if not root.left and not root.right:# temp = temp.split(',')[:-1]# temp = map(lambda x: int(x), temp)a=reduce(lambda x,y:x+y,temp)if a==sum:res.append(temp)else:temp_copy = copy.deepcopy(temp)helper(root.left,sum,temp_copy,res)helper(root.right,sum,temp,res)helper(root,sum,temp,res)return res

    def pruneTree(self, root):""":type root: TreeNode:rtype: TreeNode"""if not root:returnroot.left, root.right = self.pruneTree(root.left), self.pruneTree(root.right)return root if any([root.val, root.left, root.right]) else None

    def pruneTree(self, root):        """        :type root: TreeNode        :rtype: TreeNode        """        if root:            root.left=self.pruneTree(root.left)            root.right=self.pruneTree(root.right)            if not root.left and not root.right and root.val==0:                root=None            else:                return root        return None

class Solution(object):def printTree(self, root):""":type root: TreeNode:rtype: List[List[str]]"""h=self.height(root)matrix=[['' for m in range(2**h-1)] for n in range(h)]self.makeMatrix(root,matrix,0,(2**h)-1,0)return matrixdef height(self, node):return max(1 + self.height(node.left), 1 + self.height(node.right)) if node else 0def makeMatrix(self,root,matrix,col1,col2,h):if root:i=(col1+col2)//2matrix[h][i]=str(root.val)self.makeMatrix(root.left,matrix,col1,i-1,h+1)self.makeMatrix(root.right,matrix,i+1,col2,h+1)

    def flatten(self,root):""":type root: TreeNode:rtype: voi       #原地改动，全部取出节点到列表中，再从列表中改动成树     listTree=[]def helper(root):if root:listTree.append(root)helper(root.left)helper(root.right)helper(root)for i in range(len(listTree)):if i<len(listTree)-1:listTree[i].right=listTree[i+1]listTree[i].left=None#原地改动，将树的右节点放在栈中，将树的左节点变成树的右节点stack=[]def helper(root):if root:if root.right:stack.append(root.right)if root.left:root.right=root.leftroot.left=Noneelif not root.left and stack:root.right=stack.pop()helper(root.right)helper(root)

from collections import defaultdict
class Solution(object):def findDuplicateSubtrees(self, root):""":type root: TreeNode:rtype: List[TreeNode]"""#思路1：超出时间限制if not root:return []listNode=[]def isSameTree(p,q):if not p and not q:return Trueelif (p and not q) or (q and not p):return Falseelse:if p.val!=q.val:return Falseelse:return isSameTree(p.left,q.left) and isSameTree(p.right,q.right)                    prev=[root]while prev:node=prev.pop(0)if node:listNode.append(node)prev.extend([node.left,node.right])res=[]i=0while i < len(listNode):j=i+1flag=1while i+1 <= j < len(listNode):if isSameTree(listNode[i],listNode[j]):if listNode[i] not in res:res.append(listNode[i])del listNode[j]flag=0if flag:j+=1flag=1i+=1return res#思路2if not root:return []def order(root):orderRes=[]prev=[root]while prev:node=prev.pop()if node:orderRes.append(node.val)prev.extend([node.left,node.right])else:orderRes.append(None)return orderResprev=[root]dic=defaultdict(TreeNode)res=[]while prev:node=prev.pop()if node:if tuple(order(node)) not in dic:dic[tuple(order(node))]=nodeelse:res.append(dic[tuple(order(node))])prev.extend([node.left,node.right])return list(set(res))

    def isValidBST(self, root):""":type root: TreeNode:rtype: bool"""if not root:return Truedef compare(root,value,flag):if not root:return Truestack=[root]while stack:node=stack.pop()if node:if flag==1:if node.val>=value:return Falseelse:if node.val<=value:return Falsestack.extend([node.left,node.right])return Trueif compare(root.left,root.val,1) and compare(root.right,root.val,0):return self.isValidBST(root.left) and self.isValidBST(root.right)else:return False

    def widthOfBinaryTree(self, root):""":type root: TreeNode:rtype: int"""if not root:return 0prev,temp=[(root,1)],[]res=[]while prev:cur=[]while prev:node,index=prev.pop(0)temp.append(index)if node:if node.left:cur.append((node.left,index*2-1))if node.right:cur.append((node.right,index*2))res.append(max(temp)-min(temp))temp=[]prev=curreturn max(res)+1

class TreeNode(object):def __init__(self, x):self.val = xself.left = Noneself.right = None
def _gen_trees(start, end):if start > end:yield Nonefor j in range(start, end+1):for l_tree in _gen_trees(start, j-1):for r_tree in _gen_trees(j+1, end):root = TreeNode(j)root.left = l_treeroot.right = r_treeyield root
def generateTrees(n):if n == 0:return []return list(_gen_trees(1, n)

    def bulidTree(self,listn):if not listn:return [None]res = []for k, item in enumerate(listn):root = TreeNode(item)left = self.bulidTree(listn[:k])right = self.bulidTree(listn[k + 1:])for i in range(len(left)):for j in range(len(right)):new_root = copy.deepcopy(root)if left[i] is not None and right[j] is not None:new_root.left = left[i]new_root.right = right[j]res.append(new_root)elif left[i] is not None and right[j] is None:new_root.left = left[i]res.append(new_root)elif left[i] is None and right[j] is not None:new_root.right = right[j]res.append(new_root)if res == []:res.append(root)return res

    def allPossibleFBT(self, N):""":type N: int:rtype: List[TreeNode]"""if N == 1:return [TreeNode(0)]res = []for nleft,nright in [(i,N-1-i) for i in range(1,N,2)]:for left in self.allPossibleFBT(nleft):for right in self.allPossibleFBT(nright):root = TreeNode(0)root.left = leftroot.right = rightres.append(root)return res

class BSTIterator(object):def __init__(self, root):""":type root: TreeNode"""self.stack=[]while root:self.stack.append(root)root=root.leftdef hasNext(self):""":rtype: bool"""return len(self.stack)>0def next(self):""":rtype: int"""node=self.stack.pop()x=node.rightwhile x:self.stack.append(x)x=x.leftreturn node.val

class Solution(object):def addOneRow(self, root, v, d):""":type root: TreeNode:type v: int:type d: int:rtype: TreeNode"""if root and d==1:node=TreeNode(v)node.left=rootreturn node        prev=[root]h=1while prev:cur=[]           while prev:node=prev.pop(0)if h==d-1:copy_left=node.leftcopy_right=node.rightnode.left=TreeNode(v)node.left.left=copy_leftnode.right=TreeNode(v)node.right.right=copy_rightelse:if node.left:cur.append(node.left)if node.right:cur.append(node.right)h+=1prev=curreturn root

    def lowestCommonAncestor(self, root, p, q):""":type root: TreeNode:type p: TreeNode:type q: TreeNode:rtype: TreeNode"""if p==root or q==root or root==None:return rootelse:left=self.lowestCommonAncestor(root.left, p, q)right=self.lowestCommonAncestor(root.right, p, q)if left and not right:return leftelif not left and right:return rightelif left and right:return root