剑指offer 刷题 六 搜索与回溯（32-I 32-II 32-III）

剑指 Offer 32 - I. 从上到下打印二叉树
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

BFS：

def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: return []
        else: q.append(root)
        q = []
        li = []
        while q:
            r = q.pop(0)
            li.append(r.val)
            if r.left:
                q.append(r.left)
            if r.right:
                q.append(r.right)
        return li

官方答案：

注意官方queue的用法

剑指 Offer 32 - II. 从上到下打印二叉树 II
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

字典：

def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        dic = dict()
        level = 0
        dic[root.val] = level
        while queue:
            level += 1
            node = queue.popleft()
            cur = dic[node.val]
            if node.left:
                queue.append(node.left)
                dic[node.left.val] = level
            if node.right:
                queue.append(node.right)
                dic[node.right.val] = level
            if node.left is None and node.right is None:
                level -= 1
                break
            if queue:
                nxt = queue.popleft()
                if cur == dic[nxt.val]:
                    level -= 1
                queue.append(nxt)
        for i in range(max(dic.values())+1):
            res.append([])
        for i, ele in dic.items():
            res[ele].append(i)
        return res

只能过部分测试案例，代码有bug。

BFS:

def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            temp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                temp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(temp)
        return res

看了大佬的答案，for训练那里，巧妙的解决了所有问题。

剑指 Offer 32 - III. 从上到下打印二叉树 III
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

BFS：

def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        count = 0
        while queue:
            temp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                temp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            if (count % 2) == 0:
                res.append(temp)
            else:
                res.append(temp[::-1])
            count += 1
        return res

根据上一题的经验，又加了一个count作为奇偶判断。
奇偶法：

def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(tmp[::-1] if len(res) % 2 else tmp)
        return res

这里是大佬写的，奇偶法的判断那里是我需要学习的。

双端队列：

 def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            temp = collections.deque()
            for _ in range(len(queue)):
                node = queue.popleft()
                if len(res) % 2: temp.appendleft(node.val) # 偶数层 队头加
                else: temp.append(node.val) # 奇数层 队尾加
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(list(temp))
        return res

双端队列速度也快了