69. 二叉树的层次遍历Python实现

'''

69. 二叉树的层次遍历
描述
给出一棵二叉树，返回其节点值的层次遍历（逐层从左往右访问）

您在真实的面试中是否遇到过这个题？  
样例
给一棵二叉树 {3,9,20,#,#,15,7} ：

  3
 / \
9  20
  /  \
 15   7
返回他的分层遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

下面这个题帮助理解

7. 二叉树的序列化和反序列化
描述
设计一个算法，并编写代码来序列化和反序列化二叉树。将树写入一个文件被称为“序列化”，读取文件后重建同样的二叉树被称为“反序列化”。

如何反序列化或序列化二叉树是没有限制的，你只需要确保可以将二叉树序列化为一个字符串，并且可以将字符串反序列化为原来的树结构。

对二进制树进行反序列化或序列化的方式没有限制，LintCode将您的serialize输出作为deserialize的输入，它不会检查序列化的结果。

您在真实的面试中是否遇到过这个题？  
样例
给出一个测试数据样例， 二叉树{3,9,20,#,#,15,7}，表示如下的树结构：

  3
 / \
9  20
  /  \
 15   7
我们的数据是进行BFS遍历得到的。当你测试结果wrong answer时，你可以作为输入调试你的代码。

你可以采用其他的方法进行序列化和反序列化。
'''

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
class Solution:


    def serialize(self, root):
        if root is None:
            return "{}"

        queue = [root]
        index = 0
        while index < len(queue):
            if queue[index] is not None:
                queue.append(queue[index].left)
                queue.append(queue[index].right)
            index += 1

        while queue[-1] is None:
            queue.pop()

        return '{%s}' % ','.join([str(node.val) if node is not None else '#'
                                  for node in queue])


    def deserialize(self, data):
        data = data.strip('\n')

        if data == '{}':
            return None

        vals = data[1:-1].split(',')  #['3', '9', '20', '#', '#', '15', '7']

            
        root = TreeNode(int(vals[0]))  #[<__main__.TreeNode object at 0x1057d44a8>]

        queue = [root]  #[<__main__.TreeNode object at 0x1057d44a8>]

        isLeftChild = True
        index = 0

        for val in vals[1:]:
            if val is not '#':
                node = TreeNode(int(val))
                if isLeftChild:
                    queue[index].left = node
                else:
                    queue[index].right = node
                queue.append(node)

            if not isLeftChild:
                index += 1
            isLeftChild = not isLeftChild

        return root

class Solution1:
    """
    @param root: The root of binary tree.
    @return: Level order in a list of lists of integers
    """
    def levelOrder(self, root):
        if not root:
            return []

        queue = [root]
        results = []
        while queue:
            next_queue = []
            results.append([node.val for node in queue])
            for node in queue:
                if node.left:
                    next_queue.append(node.left)
                if node.right:
                    next_queue.append(node.right)
            queue = next_queue
        return results

my_solution = Solution()
data = "{3,9,20,#,#,15,7}"
deser = my_solution.deserialize(data) #把人能识别的东西序列化为机器能识别的. [<__main__.TreeNode object at 0x10d9e4198>]
print(deser)
ser = my_solution.serialize(deser)  #把机器能识别的反序列化为人能识别的
print(ser)
my_solution1 = Solution1()
order = my_solution1.levelOrder(deser)  #打印二叉树分层遍历结果；levelOrder括号里面是root，但是我这里放入的是整个二叉树，怎么就没有报错
print(order)


输出：
<__main__.TreeNode object at 0x10340e208>
{3,9,20,#,#,15,7}
[[3], [9, 20], [15, 7]]
[Finished in 0.0s]

认识你是我们的缘分，同学，等等，记得关注我。

 

微信扫一扫
关注该公众号