BFS

102. 二叉树的层次遍历

难度中等409收藏分享切换为英文关注反馈

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

例如:
给定二叉树: [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

from collections import deque
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = list()
        queue = deque()
        queue.append(root)
        
        while queue:
            queue_size = len(queue)
            temp_res = list()
            for _ in range(queue_size):
                temp_node = queue.popleft()
                temp_res.append(temp_node.val)
                if temp_node.left:
                    queue.append(temp_node.left)
                if temp_node.right:
                    queue.append(temp_node.right)
            res.append(temp_res)

        return res

103. 二叉树的锯齿形层次遍历

难度中等161收藏分享切换为英文关注反馈

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

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

    3
   / 
  9  20
    /  
   15   7

返回锯齿形层次遍历如下：

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

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from collections import deque
class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = list()
        queue = deque()
        queue.append(root)
        flag = True
        while queue:
            queue_size = len(queue)
            temp_res = list()
            for _ in range(queue_size):
                temp_node = queue.popleft()
                temp_res.append(temp_node.val)
                if temp_node.left:
                    queue.append(temp_node.left)
                if temp_node.right:
                    queue.append(temp_node.right)
            if flag:
                res.append(temp_res)
                flag = False
            else:
                res.append(temp_res[::-1])
                flag = True

        return res

127. 单词接龙

难度中等235收藏分享切换为英文关注反馈

给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则：

1. 每次转换只能改变一个字母。
2. 转换过程中的中间单词必须是字典中的单词。

说明:

• 如果不存在这样的转换序列，返回 0。
• 所有单词具有相同的长度。
• 所有单词只由小写字母组成。
• 字典中不存在重复的单词。
• 你可以假设 beginWord 和 endWord 是非空的，且二者不相同。

示例 1:

输入:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

输出: 5

解释: 一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog",
     返回它的长度 5。

示例 2:

输入:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

输出: 0

解释: endWord "cog" 不在字典中，所以无法进行转换。

from collections import deque
class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
        wordList = set(wordList)
        transform_times = 0
        if not wordList:
            return 0
        visited_words = set([beginWord])
        queue = deque([beginWord])

        while queue:
            transform_times += 1
            queue_length = len(queue)
            for _ in range(queue_length):
                temp = queue.popleft()
                if temp == endWord:
                    return transform_times
                for each_element in self.__get_next_words(temp):
                    if each_element in visited_words or each_element not in wordList:
                        continue
                    visited_words.add(each_element)
                    queue.append(each_element)
        
        return 0
        
 
    def __get_next_words(self, word):
        words = []
        length_word = len(word)
        for i in range(length_word):
            left, right = word[0:i], word[i+1:length_word]
            for char in "abcdefghigklmnopqrstuvwxyz":
                if char != word[i]:
                    temp_word = left + char + right
                    words.append(temp_word)
        return words

 279. 完全平方数

难度中等333收藏分享切换为英文关注反馈

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

输入: n = 12
输出: 3 
解释: 12 = 4 + 4 + 4.

示例 2:

输入: n = 13
输出: 2
解释: 13 = 4 + 9.

class Solution:
    def numSquares(self, n: int) -> int:
        queue = list()
        queue.append((n, 0))
        visited = [False for _ in range(n)]
        
        while queue:
            minuend, step = queue.pop(0)

            i = 1
            difference = minuend - i*i

            while difference >= 0:
                if difference  == 0:
                    return step+1
                
                if not visited[difference ]:
                    queue.append((difference ,step+1))
                    visited[difference] = True

                i = i + 1
                difference = minuend - i*i

 NC 序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树

 二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。

 

二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来解析回这个二叉树

示例1

输入--{8,6,10,5,7,9,11}

返回值--{8,6,10,5,7,9,11}

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
import collections
class Solution:
    def Serialize(self, root):
        # write code here
        
        if not root:
            return ""
        queue = collections.deque([root])
        res = []
        while queue:
            node = queue.popleft()
            if node:
                res.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else:
                res.append('None')
        print(res)
        return '[' + ','.join(res) + ']'
        
    def Deserialize(self, data):
        # write code here
        if not data:
            return None
        dataList = data[1:-1].split(',')
        root = TreeNode(int(dataList[0]))
        queue = collections.deque([root])
        i = 1
        while queue:
            node = queue.popleft()
            if dataList[i] != 'None':
                node.left = TreeNode(int(dataList[i]))
                queue.append(node.left)
            i += 1
            if dataList[i] != 'None':
                node.right = TreeNode(int(dataList[i]))
                queue.append(node.right)
            i += 1
        return root