力扣每日一题(五十三——广度优先遍历算法（关于树得类型题））

仅以此纪录每日LeetCode所刷题目。

题目描述：

示例：

 

思路：

这道题我们需要知道一个定理，如果存在最小高度，那么最多只有两个节点。

代码：

class Solution:
    def findMinHeightTrees(self, n: int, edges: List[List[int]]) -> List[int]:
        in_degree, connect = [0] * n, defaultdict(list)
        for a, b in edges:
            in_degree[a] += 1
            in_degree[b] += 1
            connect[a].append(b)
            connect[b].append(a)
        nodes = [i for i, v in enumerate(in_degree) if v <= 1]
        while n > 2:
            n -= len(nodes)
            nxt = []
            for node in nodes:
                for other in connect[node]:
                    in_degree[other] -= 1
                    if in_degree[other] == 1:
                        nxt.append(other)
            nodes = nxt
        return nodes

题目描述：

示例：

 

思路：

本题采用广度优先遍历算法，一层一层的遍历N叉树，在遍历该层的所有节点值之后，将该层节点的孩子节点依次全部放在新建的列表之中，之后继续遍历新建的列表。

代码：

"""
# 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 []
        list1 = []
        queue = [root]
        while queue and queue[0]:
            list1.append([a.val for a in queue])
            childroot = []
            for node in queue:
                for child in node.children:
                    childroot.append(child)
            # queue = [child for node in queue for child in node.children]
            queue = childroot
        return list1

 题目描述：

示例：

 

思路：

思路放在代码的注释里面了。

代码：

class Solution(object):
    def countComponents(self, n, edges):
        dic = collections.defaultdict(list)  # 用value默认为list的字典构图，时间复杂度最差情况为O(N^2)
        for e in edges:
            dic[e[0]].append(e[1])
            dic[e[1]].append(e[0])
        print(dic)
        visited = set()
        res = 0
        # BFS整个图，遍历时间复杂度为O(2N),遍历所有无论visited或没visited的node一次，每个node再被初次visited一次。
        for i in range(n):
            if i not in visited:
                res += 1
                q = [i]
                visited.add(i)
                while q:  # 每一次完整的BFS代表着一个连通分量的完全遍历，res += 1
                    now = q.pop(0)
                    for n in dic[now]:
                        if n not in visited:
                            visited.add(n)
                            q.append(n)
        return res  # 遍历结束输出res即为所求

 题目描述：

示例：

 

思路：

思路同第一题。

代码：

# 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 root is None:
            return []
        list1 = []
        queue = [root]
        while queue:
            childroot = []
            for i in queue:
                list1.append(i.val)
                if i.left:
                    childroot.append(i.left)
                if i.right:
                    childroot.append(i.right)
            queue = childroot
        return list1

 题目描述：

示例：

 

思路：

思路同第一题。

代码：

# 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 levelOrder(self, root: TreeNode) -> List[List[int]]:
        if root is None:
            return []
        list1 = []
        queue = [root]
        while queue:
            list2 = []
            childqueue = []
            for a in queue:
                list2.append(a.val)
                if a.left:
                    childqueue.append(a.left)
                if a.right:
                    childqueue.append(a.right)
            list1.append(list2)
            queue = childqueue
        return list1

 题目描述：

示例：

 

思路：

思路同第一题。

代码：

# 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 root is None:
            return []
        list1 = []
        queue = [root]
        i = 2
        while queue:
            if i % 2 == 1:
                a = [root.val for root in queue]
                list1.append(a[::-1])
                print(a)
            else:
                list1.append([root.val for root in queue])
            childroot = []
            for j in queue:
                if j.left:
                    childroot.append(j.left)
                if j.right:
                    childroot.append(j.right)
            queue = childroot
            i += 1
        return list1

 题目描述：

示例：

 

思路：

思路同第一题。

代码：

 

# 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 zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        if root is None:
            return []
        list1 = []
        queue = [root]
        i = 2
        while queue:
            if i % 2 == 1:
                a = [root.val for root in queue]
                list1.append(a[::-1])
                print(a)
            else:
                list1.append([root.val for root in queue])
            childroot = []
            for j in queue:
                if j.left:
                    childroot.append(j.left)
                if j.right:
                    childroot.append(j.right)
            queue = childroot
            i += 1
        return list1