附加题 60-62

面试题60：把二叉树打印成多行

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

思路梳理

新定义一个列表 level，保存每一层的非空节点，每一次循环，将每一层非空节点的值作为列表，存入结果中。

• 需要定义一个临时变量，保存当前层的节点对，然后从节点对中挑选出非空节点存为下一层的 level。

class Solution(object):
    def levelOrder(self, pRoot):
		# 保存每一层的节点
        level = [pRoot]
        ans = []
        # 循环判定条件中加入pRoot，保证了如果根节点为空，返回ans=[].
        while pRoot and level:
            ans.append([i.val for i in level ])
            LRpair = [(n.left, n.right) for n in level ]
            level = [i for leaf in LRpair for i in leaf if i is not None]
        return ans

面试题61：按之字形顺序打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

思路梳理

在层次遍历的基础上，多加一个方向的标记位即可。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def zigzagLevelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        # 定义一个标记位，如果为1则从左到右，如果为0则从右到左
        flag = 1
        level = [root]
        ans = []
        while root and level:
            if flag == 0:
                ans.append([level[i].val for i in range(-1, -len(level)-1, -1)])
            else:
                ans.append([node.val for node in level])
            LRpair = [(node.left, node.right) for node in level]
            level = [leaf for pair in LRpair for leaf in pair if leaf]
            flag = 1-flag
        return ans

面试题62：序列化二叉树

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

思路梳理

1. 由于在列表中无法保存“null”，所以使用“#”来代替空节点。
2. 本题的主函数：codec.deserialize(codec.serialize(root))；所以自己定义的两个函数只需要互相符合即可，采用相同的遍历顺序，前中后均可。
3. 采用层次遍历，即宽度优先遍历，进行序列化与反序列化；也可以采用先序遍历。

class Codec:
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if root is None:
            return []
        last_level = [root]
        next_level = []
        ans = [root.val]
        while root and last_level:
            for node in last_level:
                if node:
                    LRpair = [node.left, node.right]
                    for n in LRpair:
                        if n:
                            ans.extend([n.val])
                        else:
                            ans.extend(['#'])
                    next_level.extend([n for n in LRpair if n])
            last_level = next_level
            next_level = []
        for n in ans[::-1]:
            if n=='#':
                ans.pop()
            else:
                break
        return ans

    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        if data == []:
            return
        proot = TreeNode(data.pop(0))
        stack = [proot]
        while data and stack:
            root = stack.pop(0)
            left = data.pop(0)
            if left != '#':
                root.left = TreeNode(left)
                stack.append(root.left)
            if data:
                right = data.pop(0)
                if right != '#':
                    root.right = TreeNode(right)
                    stack.append(root.right)
                
        return proot

采用先序遍历的代码：

class Codec:
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        # 采用递归
        def doit(node):
            if node:
                vals.append(str(node.val))
                doit(node.left)
                doit(node.right)
            else:
                vals.append('#')
        vals = []
        doit(root)
        return ' '.join(vals)
                
    def deserialize(self, s):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        def doit():
            val = next(vals)
            if val == '#':
                return None
            node = TreeNode(int(val))
            node.left = doit()
            node.right = doit()
            return node
        vals = iter(s.split())
        return doit()