leetcode打卡二叉树问题（一）

---

一、二叉树的镜像

题目描述：请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

镜像输出：

     4
  /   \
  7     2
 / \   / \
9   6 3   1

示例 1：

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

代码如下
1、递归方法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        tmp=root.left
        root.left=self.mirrorTree(root.right)
        root.right=self.mirrorTree(tmp)
        return root

2、非递归方法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        stack=[root]
        while stack:
            node=stack.pop()
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            node.left,node.right=node.right,node.left
        return root

二、对称的二叉树

题目描述：请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

     1
   /   \
  2     2
 / \   / \
3   4 4   3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

代码如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def recur(L,R):
            if not L and not R:
                return True
            if not L or not R or L.val != R.val:
                return False
            return recur(L.left,R.right) and recur(L.right,R.left)
        return recur(root.left,root.right) if root else True

三、从上到下打印二叉树1

题目描述：从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7]

   3
  / \
 9  20
 /  \
15   7

返回：

[3,9,20,15,7]

代码如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: 
            return []
        l=[]
        l.append(root)
        l_new=[]
        while len(l)>0:
            root=l.pop(0)
            l_new.append(root.val)
            if root.left:
                l.append(root.left)
            if root.right:
                l.append(root.right)

        return l_new

四、从上到下打印二叉树2

题目描述：从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:

给定二叉树: [3,9,20,null,null,15,7],

   3
  / \
 9  20
    /  \
   15   7

返回其层次遍历结果：

[
[3],
[9,20],
[15,7]
]

代码如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: 
            return []
        l=[]
        l.append(root)
        l_new=[]
        while len(l)>0:
            tmp=[]
            for _ in range(len(l)):
                root=l.pop(0)
                tmp.append(root.val)
                if root.left:
                    l.append(root.left)
                if root.right:
                    l.append(root.right)
            l_new.append(tmp)
        return l_new

五、从上到下打印二叉树3

题目描述：请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7],

   3
  / \
 9  20
    /  \
   15   7

返回其层次遍历结果：

[
[3],
[20,9],
[15,7]
]

代码如下
1、代码一

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, deque = [], collections.deque([root])
        while deque:
            tmp = collections.deque()
            for _ in range(len(deque)):
                node = deque.popleft()
                if len(res) % 2: tmp.appendleft(node.val) # 偶数层 -> 队列头部
                else: tmp.append(node.val) # 奇数层 -> 队列尾部
                if node.left: deque.append(node.left)
                if node.right: deque.append(node.right)
            res.append(list(tmp))
        return res

2、代码二

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        l=[root]
        new_l=[]
        t=1
        while len(l)>0:
            tmp=[]
            for _ in range(len(l)):
                root=l.pop(0) 
                tmp.append(root.val)
                if root.left:
                    l.append(root.left)
                    
                if root.right:
                    l.append(root.right)
            tmp=tmp[::-1] if t%2==0 else tmp       
            new_l.append(tmp)
            t+=1
        return new_l

---