94. 二叉树的中序遍历
python
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: Optional[TreeNode]
:rtype: List[int]
"""
def inorder(root):
if not root:
return
inorder(root.left)
res.append(root.val)
inorder(root.right)
res = []
inorder(root)
return res补充：前序遍历 and 后序遍历
python
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: Optional[TreeNode]
:rtype: List[int]
"""
def inorder(root):
if not root:
return
inorder(root.left)
res.append(root.val)
inorder(root.right)
res = []
inorder(root)
return res
def preorderTraversal(self, root):
"""
:type root: Optional[TreeNode]
:rtype: List[int]
"""
def preorder(root):
if not root:
return
res.append(root.val)
preorder(root.left)
preorder(root.right)
res = []
preorder(root)
return res
def postorderTraversal(self, root):
"""
:type root: Optional[TreeNode]
:rtype: List[int]
"""
def postorder(root):
if not root:
return
postorder(root.left)
postorder(root.right)
res.append(root.val)
res = []
postorder(root)
return res遍历迭代版本
python
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: Optional[TreeNode]
:rtype: List[int]
"""
st = []
res = []
p = root
while p or st:
# 先找到最左边的节点
while p:
st.append(p)
p = p.left
# st的最后一个元素就是最左边的节点
p = st.pop()
res.append(p.val)
# 处理右子树
p = p.right
return res
def preorderTraversal(self, root):
"""
:type root: Optional[TreeNode]
:rtype: List[int]
"""
if not root:
return []
st = [root]
res = []
while st:
p = st.pop()
res.append(p.val)
# 先压入右节点，让左节点先弹出
if p.right:
st.append(p.right)
if p.left:
st.append(p.left)
return res
def postorderTraversal(self, root):
"""
:type root: Optional[TreeNode]
:rtype: List[int]
"""
if not root:
return []
st = [root]
res = []
while st:
p = st.pop()
res.append(p.val)
# 先压入左节点，让右节点先弹出
if p.left:
st.append(p.left)
if p.right:
st.append(p.right)
# 头 右 左
# 翻转：左 右 头
return res[::-1]空间复杂度：O(n)
时间复杂度：O(n)
104. 二叉树的最大深度
深搜版本：
python
class Solution(object):
def maxDepth(self, root):
"""
:type root: Optional[TreeNode]
:rtype: int
"""
# 深搜
if not root:
return 0
left_h = self.maxDepth(root.left)
right_h = self.maxDepth(root.right)
return max(left_h,right_h)+1
python
class Solution(object):
def maxDepth(self, root):
"""
:type root: Optional[TreeNode]
:rtype: int
"""
# 深搜
return 0 if not root else max(self.maxDepth(root.left),self.maxDepth(root.right))+1时间复杂度：O(N)
空间复杂度：O(H) 【H 平均是log N的高度，最差是N】
python
class Solution(object):
def maxDepth(self, root):
"""
:type root: Optional[TreeNode]
:rtype: int
"""
# 广搜
if not root:
return 0
queue = [(root,1)]
while queue:
node,height = queue.pop(0)
if node.left: queue.append((node.left,height+1))
if node.right:queue.append((node.right,height+1))
return height时间复杂度：O(N)
空间复杂度：O(N)
226. 翻转二叉树
python
class Solution(object):
def invertTree(self, root):
"""
:type root: Optional[TreeNode]
:rtype: Optional[TreeNode]
"""
if not root:
return root
root.left,root.right = self.invertTree(root.right),self.invertTree(root.left)
return root时间复杂度：O(N)
空间复杂度：O(H) 【H 平均是log N的高度，最差是N】
101. 对称二叉树
递归：
python
class Solution(object):
def check(self,left,right):
if not left and not right:
return True
if not left or not right:
return False
if left.val != right.val:
return False
return self.check(left.left,right.right) and self.check(left.right,right.left)
def isSymmetric(self, root):
"""
:type root: Optional[TreeNode]
:rtype: bool
"""
if not root:
return True
return self.check(root.left,root.right)时间复杂度：O(N)
空间复杂度：O(N)
迭代：
python
class Solution(object):
def isSymmetric(self, root):
"""
:type root: Optional[TreeNode]
:rtype: bool
"""
if not root:
return True
queue = [root.left,root.right]
while queue:
left = queue.pop(0)
right = queue.pop(0)
if not left and not right:
continue
if (not left or not right) or left.val != right.val:
return False
queue.append(left.left)
queue.append(right.right)
queue.append(left.right)
queue.append(right.left)
return True时间复杂度：O(N)
空间复杂度：O(N)
543. 二叉树的直径
python
class Solution(object):
def depth(self,root):
if not root:
return 0
left_h = self.depth(root.left)
right_h = self.depth(root.right)
self.ans = max(self.ans,left_h+right_h)
return max(left_h,right_h)+1
def diameterOfBinaryTree(self, root):
"""
:type root: Optional[TreeNode]
:rtype: int
"""
# 任意一颗子树的直径都可以表示为(左子树深度+右子树深度+1)-1 = 左子树深度+右子树深度
# 我们只要利用ans记录最大值即可【这个直径不一定出现在根节点，想象一颗左子树和右子树极度不平衡的树】
# 1
# 2
# 3 4
# 5 6
self.ans = 0
self.depth(root)
return self.ans时间复杂度：O(N)
空间复杂度：O(H) 【H 平均是log N的高度，最差是N】