LeetCode 第八天 二叉树2 层序遍历 python

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

# 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 rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if(root==None):
            return []
        res=[]
        res.append(root.val)
        que=[]
        if (root.left!=None):
            que.append(root.left)
        if (root.right!=None):
            que.append(root.right)
        while(len(que)!=0):
            size=len(que)
            for i in range(size):
                child=que.pop(0)
                if i==size-1:
                    res.append(child.val)
                if (child.left!=None):
                    que.append(child.left)
                if (child.right!=None):
                    que.append(child.right)
        return res

637. 二叉树的层平均值
给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

# 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 averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        if(root==None):
            return []
        res=[]
        res.append(root.val)
        que=[]
        if (root.left!=None):
            que.append(root.left)
        if (root.right!=None):
            que.append(root.right)
        while(len(que)!=0):
            size=len(que)
            sum=0
            for i in range(size):
                child=que.pop(0)
                sum=sum+child.val
                
                if (child.left!=None):
                    que.append(child.left)
                if (child.right!=None):
                    que.append(child.right)
            
            res.append(sum/size)
        return res

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

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

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if(root==None):
            return []
        res=[[root.val]]
        que=[]
        if root.children!=None:
            for chi in root.children:
                que.append(chi)

        while(len(que)!=0):
            size=len(que)
            temp=[]
            for i in range(size):
                child=que.pop(0)
                temp.append(child.val)
                if (child.children!=None):
                    for chi in child.children:
                        que.append(chi)

            res.append(temp)
        return res

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

# 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 largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if(root==None):
            return []
        res=[]
        res.append(root.val)
        que=[]
        if (root.left!=None):
            que.append(root.left)
        if (root.right!=None):
            que.append(root.right)
        while(len(que)!=0):
            size=len(que)
            max_=-2147483649
            for i in range(size):
                child=que.pop(0)
                if child.val>max_:
                    max_=child.val
                
                if (child.left!=None):
                    que.append(child.left)
                if (child.right!=None):
                    que.append(child.right)
            
            res.append(max_)
        return res

117. 填充每个节点的下一个右侧节点指针 II
给定一个二叉树：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

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

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if(root==None):
            return root
        que=[]
        if (root.left!=None):
            que.append(root.left)
        if (root.right!=None):
            que.append(root.right)
        while(len(que)!=0):
            size=len(que)
            
            for i in range(size):
                child=que.pop(0)
                # res.append(child.val)
                if i==0:
                    head=child  
                else:
                    head.next=child
                    head=child
                if (child.left!=None):
                    que.append(child.left)
                if (child.right!=None):
                    que.append(child.right)
            
            # res.append('#')
        return root