BFS

102. 二叉树的层次遍历

难度中等

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

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]
 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 
 8 from collections import deque
 9 class Solution:
10     def levelOrder(self, root: TreeNode) -> List[List[int]]:
11         if not root:
12             return []
13         res = list()
14         queue = deque()
15         queue.append(root)
16         
17         while queue:
18             queue_size = len(queue)
19             temp_res = list()
20             for _ in range(queue_size):
21                 temp_node = queue.popleft()
22                 temp_res.append(temp_node.val)
23                 if temp_node.left:
24                     queue.append(temp_node.left)
25                 if temp_node.right:
26                     queue.append(temp_node.right)
27             res.append(temp_res)
28 
29         return res
View Code

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

难度中等

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

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

    3
   / \
  9  20
    /  \
   15   7

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

[
  [3],
  [20,9],
  [15,7]
]
 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 from collections import deque
 8 class Solution:
 9     def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
10         if not root:
11             return []
12         res = list()
13         queue = deque()
14         queue.append(root)
15         flag = True
16         while queue:
17             queue_size = len(queue)
18             temp_res = list()
19             for _ in range(queue_size):
20                 temp_node = queue.popleft()
21                 temp_res.append(temp_node.val)
22                 if temp_node.left:
23                     queue.append(temp_node.left)
24                 if temp_node.right:
25                     queue.append(temp_node.right)
26             if flag:
27                 res.append(temp_res)
28                 flag = False
29             else:
30                 res.append(temp_res[::-1])
31                 flag = True
32 
33         return res
View Code

127. 单词接龙

难度中等

给定两个单词（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" 不在字典中，所以无法进行转换。
 1 from collections import deque
 2 class Solution:
 3     def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
 4         wordList = set(wordList)
 5         transform_times = 0
 6         if not wordList:
 7             return 0
 8         visited_words = set([beginWord])
 9         queue = deque([beginWord])
10 
11         while queue:
12             transform_times += 1
13             queue_length = len(queue)
14             for _ in range(queue_length):
15                 temp = queue.popleft()
16                 if temp == endWord:
17                     return transform_times
18                 for each_element in self.__get_next_words(temp):
19                     if each_element in visited_words or each_element not in wordList:
20                         continue
21                     visited_words.add(each_element)
22                     queue.append(each_element)
23         
24         return 0
25         
26  
27     def __get_next_words(self, word):
28         words = []
29         length_word = len(word)
30         for i in range(length_word):
31             left, right = word[0:i], word[i+1:length_word]
32             for char in "abcdefghigklmnopqrstuvwxyz":
33                 if char != word[i]:
34                     temp_word = left + char + right
35                     words.append(temp_word)
36         return words
View Code

 279. 完全平方数

难度中等

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

示例 1:

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

示例 2:

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

 1 class Solution:
 2     def numSquares(self, n: int) -> int:
 3         queue = list()
 4         queue.append((n, 0))
 5         visited = [False for _ in range(n)]
 6         
 7         while queue:
 8             minuend, step = queue.pop(0)
 9 
10             i = 1
11             difference = minuend - i*i
12 
13             while difference >= 0:
14                 if difference  == 0:
15                     return step+1
16                 
17                 if not visited[difference ]:
18                     queue.append((difference ,step+1))
19                     visited[difference] = True
20 
21                 i = i + 1
22                 difference = minuend - i*i
View Code

 NC 序列化二叉树

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

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

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

示例1

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

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

 1 # -*- coding:utf-8 -*-
 2 # class TreeNode:
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 import collections
 8 class Solution:
 9     def Serialize(self, root):
10         # write code here
11         
12         if not root:
13             return ""
14         queue = collections.deque([root])
15         res = []
16         while queue:
17             node = queue.popleft()
18             if node:
19                 res.append(str(node.val))
20                 queue.append(node.left)
21                 queue.append(node.right)
22             else:
23                 res.append('None')
24         print(res)
25         return '[' + ','.join(res) + ']'
26         
27     def Deserialize(self, data):
28         # write code here
29         if not data:
30             return None
31         dataList = data[1:-1].split(',')
32         root = TreeNode(int(dataList[0]))
33         queue = collections.deque([root])
34         i = 1
35         while queue:
36             node = queue.popleft()
37             if dataList[i] != 'None':
38                 node.left = TreeNode(int(dataList[i]))
39                 queue.append(node.left)
40             i += 1
41             if dataList[i] != 'None':
42                 node.right = TreeNode(int(dataList[i]))
43                 queue.append(node.right)
44             i += 1
45         return root
View Code

 

posted @ 2020-03-24 10:51  aiwenhua_0610  阅读(142)  评论(0)  编辑  收藏  举报