Update 0226.翻转二叉树.md

This commit is contained in:
jianghongcheng
2023-05-03 20:25:30 -05:00
committed by GitHub
parent de7c67c35a
commit 54bcab13e3

View File

@ -314,81 +314,158 @@ class Solution {
递归法:前序遍历: 递归法:前序遍历:
```python ```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution: class Solution:
def invertTree(self, root: TreeNode) -> TreeNode: def invertTree(self, root: TreeNode) -> TreeNode:
if not root: if not root:
return None return None
root.left, root.right = root.right, root.left #中 root.left, root.right = root.right, root.left
self.invertTree(root.left) #左 self.invertTree(root.left)
self.invertTree(root.right) #右 self.invertTree(root.right)
return root return root
``` ```
递归法:序遍历: 迭代法:序遍历:
```python ```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution: class Solution:
def invertTree(self, root: TreeNode) -> TreeNode: def invertTree(self, root: TreeNode) -> TreeNode:
if root is None: if not root:
return None
stack = [root]
while stack:
node = stack.pop()
node.left, node.right = node.right, node.left
if node.left:
stack.append(node.left)
if node.right:
stack.append(node.right)
return root
```
递归法:中序遍历:
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return None
self.invertTree(root.left)
root.left, root.right = root.right, root.left
self.invertTree(root.left)
return root
```
迭代法:中序遍历:
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return None
stack = [root]
while stack:
node = stack.pop()
if node.left:
stack.append(node.left)
node.left, node.right = node.right, node.left
if node.left:
stack.append(node.left)
return root
```
递归法:后序遍历:
```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return None return None
self.invertTree(root.left) self.invertTree(root.left)
self.invertTree(root.right) self.invertTree(root.right)
root.left, root.right = root.right, root.left root.left, root.right = root.right, root.left
return root return root
``` ```
迭代法:深度优先遍历(前序遍历 迭代法:序遍历:
```python ```python
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution: class Solution:
def invertTree(self, root: TreeNode) -> TreeNode: def invertTree(self, root: TreeNode) -> TreeNode:
if not root: if not root:
return root return None
st = [] stack = [root]
st.append(root) while stack:
while st: node = stack.pop()
node = st.pop()
node.left, node.right = node.right, node.left #中
if node.right:
st.append(node.right) #右
if node.left: if node.left:
st.append(node.left) #左 stack.append(node.left)
if node.right:
stack.append(node.right)
node.left, node.right = node.right, node.left
return root return root
``` ```
迭代法:广度优先遍历(层序遍历): 迭代法:广度优先遍历(层序遍历):
```python ```python
import collections # Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution: class Solution:
def invertTree(self, root: TreeNode) -> TreeNode: def invertTree(self, root: TreeNode) -> TreeNode:
queue = collections.deque() #使用deque() if not root:
if root: return None
queue.append(root)
queue = collections.deque([root])
while queue: while queue:
size = len(queue) for i in range(len(queue)):
for i in range(size):
node = queue.popleft() node = queue.popleft()
node.left, node.right = node.right, node.left #节点处理 node.left, node.right = node.right, node.left
if node.left: if node.left: queue.append(node.left)
queue.append(node.left) if node.right: queue.append(node.right)
if node.right:
queue.append(node.right)
return root
```
迭代法:广度优先遍历(层序遍历),和之前的层序遍历写法一致:
```python
class Solution:
def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
if not root: return root
from collections import deque
que=deque([root])
while que:
size=len(que)
for i in range(size):
cur=que.popleft()
cur.left, cur.right = cur.right, cur.left
if cur.left: que.append(cur.left)
if cur.right: que.append(cur.right)
return root return root
``` ```
### Go ### Go
递归版本的前序遍历 递归版本的前序遍历