力扣刷题｜二叉树

参考笔记：代码随想录

二叉树的递归遍历：

递归算法的三个要素：

1: 确定递归函数的参数和返回值。

2: 确定递归的终止条件。

3: 确定单层递归的逻辑。

以力扣题目来实际操作：

144.二叉树的前序遍历

题目：给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

确定递归函数的参数和返回值：传入的是二叉树的根节点，然后需要返回的是遍历的结果，所以需要一个数组来存储。

确定递归的终止条件：终止条件是当前遍历的节点为空（左右指针的节点都指向None），然后直接return。

确定单层递归的逻辑：在前序遍历中，它的逻辑就是中左右，中就是当前的值，左右就是左右的指针。

python代码：

class TreeNode:
    def __init__(self,val=0,left = None,right = None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def preorderTraversal(self,root:TreeNode)->list[int]:
        res =[]
        def dfs(node):
            if node is None:
                return
            res.append(node.val)
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return res

# 构建树结构
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)

solution = Solution()
preorder = solution.preorderTraversal(root)
print(preorder)

145.二叉树的后序遍历

题目：给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

这里只是它的逻辑变成了左右中。

python代码：

class Solution(object):
    def postorderTraversal(self, root):
        res = []
        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            dfs(node.right)
            res.append(node.val)
        dfs(root)
        return res

问题：

这个题目前还有一个问题，我的代码如下：

class TreeNode:
    def __init__(self,val=0,left = None,right = None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def preorderTraversal(self,root:TreeNode)->list[int]:
        res =[]
        def dfs(node):
            if node is None:
                return
            print('left0:',res)
            dfs(node.left)
            print('left:',res)
            dfs(node.right)         
            print('right:',res)
            res.append(node.val)
            print('res:',res)
        dfs(root)
        return res

# 构建树结构
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)

solution = Solution()
preorder = solution.preorderTraversal(root)
print(preorder)

#输出：
left0: []
left: []
left0: []
left0: []
left: []
right: []
res: [3]
left: [3]
right: [3]
res: [3, 2]
right: [3, 2]
res: [3, 2, 1]
[3, 2, 1]

我目前还没有弄明白，得到res:[3]后，它下面的输出是怎么回事，如何进行回溯的？是回溯吗？我也不清楚。

94.二叉树的中序遍历

题目：给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

python代码：

class Solution(object):
    def inorderTraversal(self, root):
        res = []
        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)
        dfs(root)
        return res

二叉树的迭代遍历：

除了递归外，也可以用栈实现了二叉树前后中序的迭代遍历（非递归）。

刷第二遍的时候再来使用这种方法吧，现在先掌握递归的方法。

二叉树层序遍历：

层序遍历就是就是从左到右一层一层的去遍历二叉树。需要借用一个辅助数据结构即队列来实习，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

102.二叉树的层序遍历

先用数组的方式来写：先判断根节点是不是为空，如果是就返回一个空数组。然后创一个空的ans数组来存储结果，cur数组赋值为根节点。循环的条件是cur数组为不为空，不为空就继续遍历，创一个nxt的空数组来存储cur的左孩子，vals的空数组来存储val。遍历cur里面的节点，把val存到vals里，如果它有左节点，把左节点存到nxt里，同样，右节点也是。然后把cur更新为nxt，同时把vals里面的值加到ans里面。然后下一次遍历的时候就有清空nxt和vals里面的值。（多写两遍吧！！！容易忘记，特别是好多数组）注意，这里的ans与vals两个数组都必须要，现在这样，返回的是一个嵌套的列表，比如：[[3],[9,20],[15,7]]，而如果没有最后的ans.append(vals)，返回的是一个整数列表。

python代码（数组）：

class Solution:
    def levelOrder(self,root):
        if root is None:
            return []
        ans = []
        cur = [root]
        while cur:
            nxt = []
            vals = []
            for node in cur:
                vals.append(node.val)
                if node.left:
                    nxt.append(node.left)
                if node.right:
                    nxt.append(node.right)
            cur = nxt
            ans.append(vals)
        return ans

python代码（队列）：

在数组里面，用了cur和nxt两个数组，但只用一个数组的话，就需要用到队列这种数据结构，它是先进先出，或者左出右进。在python里用双端队列deque表示队列，这里主要就是使用了q.popleft()

class Solution:
    def levelOrder(self,root):
        if root is None:
            return []
        ans = []
        q = deque([root])
        while q:
            vals = []
            for _ in range(len(q)):
                node = q.popleft()
                vals.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            ans.append(vals)
        return ans

226. 翻转二叉树

题目：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

题目思路：这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次.（记住？）

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
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

101. 对称二叉树​​​​​​​

题目：给你一个二叉树的根节点 root ， 检查它是否轴对称。

算法思路：