• 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
  • 相关阅读:
    前端3 浮动布局,固定定位,绝对定位,相对定位
    前端2 字体|文本属性样式, 高级选择器
    前端1.概念
    前端,基础选择器,嵌套关系.display属性,盒模型
    数据库之索引
    数据库之进阶(视图,事务,存储过程)
    数据库,多表数据
    数据库之表的使用
    数据的演化（数据仓库的发展史）
    HDFS退出安全模式
  • 原文地址：https://www.cnblogs.com/dede-0119/p/12508984.html
Copyright © 2020-2023  润新知