目录
102. Binary Tree Level Order Traversal
100. Same Tree
class Solution(object):
def isSameTree(self, p, q):
"""
:type p: TreeNode
:type q: TreeNode
:rtype: bool
"""
def pre(x,y):
if x==None and y==None:
return True
elif x==None or y==None:
return False
if x.val!=y.val:
return False
return pre(x.left,y.left) and pre(x.right,y.right)
return pre(p,q)101. Symmetric Tree
class Solution(object):
def isSymmetric(self, root):
"""
:type root: TreeNode
:rtype: bool
"""
path=[]
values=[]
if not root:
return True
if root.left==None and root.right==None:
return True
def r(node,p,v):
v.append(node.val)
if node.left==None and node.right==None:
path.append(p)
values.append(v)
return
if node.left:
k=p[::]
k.append(1)
r(node.left,k,v[::])
if node.right:
k=p[::]
k.append(-1)
r(node.right,k,v[::])
r(root,[],[])
print(path,values)
l=len(path)
if l!=len(values) or l%2==1:
return False
def list_equal(x,y):
if len(x)!=len(y):
return False
for i in range(len(x)):
if x[i]+y[i]!=0:
return False
return True
for i in range(l):
if list_equal(path[i],path[l-1-i]) and values[i]==values[l-i-1]:
pass
else:
return False
return True102. Binary Tree Level Order Traversal
class Solution(object):
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
queue=[root]
res=[]
if not root:
return []
while queue:
# res.append()
tmp,k=[],[]
for i in queue:
k.append(i.val)
if i.left:
tmp.append(i.left)
if i.right:
tmp.append(i.right)
queue=tmp
res.append(k)
return res112. Path Sum
class Solution(object):
def hasPathSum(self, root, sum):
"""
:type root: TreeNode
:type sum: int
:rtype: bool
"""
def ge(node,i):
if node==None:
return False
if i==node.val and node.left==None and node.right==None:
return True
return ge(node.left,i-node.val) or ge(node.right,i-node.val)
return ge(root,sum)113. Path Sum II
112稍微修改一下就好，每次传入一个path，每次试着加入节点，如果当前path的和等于sum，且不能往下走，这时就可以append到结果里。注意传p时，应该传深拷贝的值。
class Solution(object):
def pathSum(self, root, k):
"""
:type root: TreeNode
:type sum: int
:rtype: List[List[int]]
"""
visited=[]
def ge(node,p):
if node==None:
return
p.append(node.val)
if sum(p)==k and node.left==None and node.right==None:
# print(p)
visited.append(p)
print(p)
ge(node.left,p[::])
ge(node.right,p[::])
ge(root,[])
return visited129. Sum Root to Leaf Numbers
先遍历得到所有的路径，然后计算。
class Solution(object):
def sumNumbers(self, root):
"""
:type root: TreeNode
:rtype: int
"""
if not root:
return 0
path=[]
def k(node,p):
if node:
p.append(node.val)
else:
return
if node.left==None and node.right==None:
path.append(p)
return
else:
k(node.left,p[::])
k(node.right,p[::])
k(root,[])
sum=0
for p in path:
for i in range(1,len(p)+1):
sum+=p[-i]*10**(i-1)
return sum226. Invert Binary Tree
class Solution(object):
def invertTree(self, root):
"""
:type root: TreeNode
:rtype: TreeNode
"""
def invert(node):
if not node:
return
invert(node.left)
invert(node.right)
tmp=node.left
node.left=node.right
node.right=tmp
invert(root)
return root257. Binary Tree Paths
class Solution(object):
def binaryTreePaths(self, root):
"""
:type root: TreeNode
:rtype: List[str]
"""
visited=[]
def c(p):
res=[]
for each in p:
x=''
for i in each:
x+=str(i)+'->'
x=x[:-2]
res.append(x)
return res
def ge(node,p):
if node==None:
return
p.append(node.val)
if node.left==None and node.right==None:
# print(p)
visited.append(p)
# print(p)
ge(node.left,p[::])
ge(node.right,p[::])
ge(root,[])
return c(visited)