Leetcode--------二叉树Part1

二叉树的定义：

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

144. 二叉树的前序遍历

代码：

# 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 preorderTraversal(self, root: TreeNode) -> List[int]:
        #第一步：确定遍历函数的参数、返回值,参数当然是当前节点了，只是打印，没有其他
        #业务，因此不需要返回值.即:return
        res = []
        def traversal(root: TreeNode):
            if root == None:
                return
            res.append(root.val)
            traversal(root.left)
            traversal(root.right)
        traversal(root)
        return res

145.二叉树的后序遍历

代码：

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def traversal(root: TreeNode):
            if root == None:
                return
            traversal(root.left)
            traversal(root.right)
            res.append(root.val)
        traversal(root)
        return res

 94. 二叉树的中序遍历

代码：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def traversal(root: TreeNode):
            if root == None:
                return
            traversal(root.left)
            res.append(root.val)
            traversal(root.right)
        traversal(root)
        return res

102. 二叉树的层序遍历

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：
二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层序遍历结果：

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

代码：

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        """
        使用队列：
        首先将根节点入队列，然后出列，每次出列时将其左右子节点都入队列
        入完队列后，再继续出列，同理，出列时候将其左右子节点入列，直到队列为空
        """
        if root == None:
            return []
        #把根节点放入队列中
        queue = [root]
        out_list = []
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            in_list = []
            for _ in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                in_list.append(cur_node.val)
                #若左子节点不为空
                if cur_node.left != None:
                    queue.append(cur_node.left)
                if cur_node.right != None:
                    queue.append(cur_node.right)
            out_list.append(in_list)
                
        return out_list

107. 二叉树的层序遍历 II

给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的层序遍历为：

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

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        """
        和102题相比，把数组反一下就好了
        """
        if root == None:
            return []
        #把根节点放入队列中
        queue = [root]
        out_list = []
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            in_list = []
            for _ in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                in_list.append(cur_node.val)
                #若左子节点不为空
                if cur_node.left != None:
                    queue.append(cur_node.left)
                if cur_node.right != None:
                    queue.append(cur_node.right)
            out_list.append(in_list)
        #将out_list反转下
        out_list.reverse()     
        return out_list

199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

 

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

class Solution:
    def rightSideView(self, root: TreeNode) -> List[int]:
        """
        在层序遍历的时候，判断如果当前元素为单层最后一个元素就放入列表就行
        """
        """
        同时：这道题目用deque比较好
        deque来自collections模块，不在力扣平台时，需要手动写入
        'from collections import deque' 导入
        deque相比list的好处是，list的pop(0)是O(n)复杂度，deque的popleft()是O(1)复杂度
        """
        if root == None:
            return []
        #把根节点放入队列中
        queue = [root]
        out_list = []
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            #取出当前层最后一个元素
            node = queue[-1]
            out_list.append(node.val)
            for _ in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                #若左子节点不为空
                if cur_node.left != None:
                    queue.append(cur_node.left)
                if cur_node.right != None:
                    queue.append(cur_node.right)
                
        return out_list

637. 二叉树的层平均值

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

示例 1：

输入：
    3
   / \
  9  20
    /  \
   15   7
输出：[3, 14.5, 11]
解释：
第 0 层的平均值是 3 ,  第1层是 14.5 , 第2层是 11 。因此返回 [3, 14.5, 11] 。

代码：

class Solution:
    def averageOfLevels(self, root: TreeNode) -> List[float]:
        if root == None:
            return []
        #把根节点放入队列中
        queue = [root]
        out_list = []
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            in_list = []
            for _ in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                in_list.append(cur_node.val)
                #若左子节点不为空
                if cur_node.left != None:
                    queue.append(cur_node.left)
                if cur_node.right != None:
                    queue.append(cur_node.right)
            out_list.append(in_list)
        #对每一层的节点求和
        out_list = map(lambda x:sum(x)/len(x),out_list)
        return out_list

429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

代码：

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        """
        相比于二叉树的层次遍历，我们只需要将当前节点的所有孩子节点都压入栈中
        """
        if root == None:
            return []
        #把根节点放入队列中
        queue = [root]
        out_list = []
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            in_list = []
            for _ in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                in_list.append(cur_node.val)
                #将该节点的所有孩子节点都压入栈中
                for chil in cur_node.children:
                    queue.append(chil)
            out_list.append(in_list)
    
        return out_list

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]
解释:
          1
         / \
        3   2
       / \   \  
      5   3   9 

代码：

class Solution:
    def largestValues(self, root: TreeNode) -> List[int]:
        if root == None:
            return []
        #把根节点放入队列中
        queue = [root]
        out_list = []
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            in_list = []
            for _ in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                in_list.append(cur_node.val)
                #若左子节点不为空
                if cur_node.left != None:
                    queue.append(cur_node.left)
                if cur_node.right != None:
                    queue.append(cur_node.right)
            out_list.append(max(in_list))
        #对每一层的节点求最大值
        return out_list

116. 填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

示例：

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

代码：

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if root == None:
            return None
        #把根节点放入队列中
        queue = [root]
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            in_list = []
            for i in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                in_list.append(cur_node.val)
                #若左子节点不为空
                if cur_node.left != None:
                    queue.append(cur_node.left)
                if cur_node.right != None:
                    queue.append(cur_node.right)
                #当前层的最后一个节点
                if i == length-1:
                    break
                #因为当前节点已经出列了，那么当前节点的下一个节点就是位于队首的节点
                cur_node.next = queue[0]
                
        return root

117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

示例：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

 代码：

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if root == None:
            return None
        #把根节点放入队列中
        queue = [root]
        while len(queue) > 0:
            #len = 1
            length = len(queue)
            in_list = []
            for i in range(length):
                #取出根节点
                cur_node = queue.pop(0)
                in_list.append(cur_node.val)
                #若左子节点不为空
                if cur_node.left != None:
                    queue.append(cur_node.left)
                if cur_node.right != None:
                    queue.append(cur_node.right)
                #当前层的最后一个节点
                if i == length-1:
                    break
                #因为当前节点已经出列了，那么当前节点的下一个节点就是位于队首的节点
                cur_node.next = queue[0]
                
        return root