python leetcode刷题知识点笔记2

二叉树的最大深度

第一种方法：BFS广度优先搜索，使用双端队列deque（因为性能比另外两种Queue好得多），在大循环内对二叉树的每个层做一次遍历，range(len(queue))使只遍历当前的层，每次大循环ans加1。由于每个节点仅访问一次，所以时间复杂度O(n)

import collections
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        queue = collections.deque()
        queue.append(root)
        ans = 0
        while queue:
            ans += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return ans

第二种方法：DFS深度优先搜索，利用递归的栈，借助level标记当前层，由于每个节点仅访问一次，所以时间复杂度O(n)

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        self.ans = 0
        self._dfs(root, 0)
        return self.ans
        
    def _dfs(self, node, level):
        if not node:
            return
        if self.ans < level + 1:
            self.ans = level + 1
        self._dfs(node.left, level + 1)
        self._dfs(node.right, level + 1)

第三种方法：DFS+分治，虽然代码简洁但耗时比上面两种方法都久

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

fromkeys(键，值)前面的键对应后面列表的值

以下实例展示了 fromkeys() 方法的使用方法：
iterable1 = “12” # 字符串
iterable2 = [1,2] # 列表
iterable3 = (1,2) # 元祖
iterable4 = {1:‘one’,2:‘two’} # 字典

v1 = dict.fromkeys(iterable1,‘字符串’)
v2 = dict.fromkeys(iterable2,‘列表’)
v3 = dict.fromkeys(iterable3,‘元祖’)
v4 = dict.fromkeys(iterable4,‘字典’)
v5 = dict.fromkeys(iterable4) #value默认为None
以上实例输出结果为：

{‘1’: ‘字符串’, ‘2’: ‘字符串’}
{1: ‘列表’, 2: ‘列表’}
{1: ‘元祖’, 2: ‘元祖’}
{1: ‘字典’, 2: ‘字典’}
{1: None, 2: None}

ord(x)将字符x转化为对应码的数字