二叉树的层次遍历反序列化，在本地构建LeetCode中的树（Python）

我最近刷LeetCode，通过率明显低于均值。然而OJ的debug功能基本都要收费，没钱充会员。人又菜，家里又穷。作为自力更生的一小步，有必要自己在本地写一个类似的功能，以方便日后刷题时debug。这篇先上树（？），下次有其他的数据结构再写吧，也第一时间share。

---

更新日志

3/29/2021 用collections.deque替换了原来的切片操作

---

养成好习惯，先上代码

先是类的定义

from collections import deque

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

class BiTreeHelper(object):
    def __init__(self, nodeList=None):
        self.nodeList = nodeList
        self.root = self.generate()

    def generate(self):
        nodeList = deque(self.nodeList)
        # nodeList == []
        if not nodeList:
            print("Empty nodeList!")
            return None

        # nodeList == [null, ...]
        head_val = nodeList.popleft()
        if not head_val:
            print("The value of head node is None!")
            return None
        vacancy = 2 # How many empty seats, if the value is even, \
        			# then the next node to be added must be the left node
        root = TreeNode(head_val)
        queue = deque([root])

        while nodeList:
            # Create current treenode
            curr_val = nodeList.popleft()
            if not curr_val and curr_val != 0:
                curr = None
            else:
                curr = TreeNode(curr_val)
                queue.append(curr)
                vacancy = vacancy + 2
            
            # Link to its parent
            parent = queue[0]
            if not parent.left and vacancy % 2 == 0:
            	# if parent.left is available
                parent.left = curr
            else:
                parent.right = curr
                queue.popleft()
            vacancy = vacancy -1
        return root

    def inorder_traversal_print(self, root=None):
        print("BiTree inorder traversal print:")
        if not root:
            root = self.root
        self.dfs(root)

    def dfs(self, root):
        if root:
            self.dfs(root.left)
            print(root.val)
            self.dfs(root.right)

---

具体在题目中的使用

举个栗子， 872. 叶子相似的树，随便写一个暴力的solution。

class Solution(object):
    def __init__(self):
        self.l_leafs = []
        self.r_leafs = []
    def leafSimilar(self, root1, root2):
        """
        :type root1: TreeNode
        :type root2: TreeNode
        :rtype: bool
        """
        self.dfs(root1, self.l_leafs)
        self.dfs(root2, self.r_leafs)
        return self.l_leafs == self.r_leafs
    
    def dfs(self, root, leafs):
        if root:
            self.dfs(root.left, leafs)
            if not root.left and not root.right:
                leafs.append(root.val)
            self.dfs(root.right, leafs)

main中的写法

if __name__ == '__main__':
    nl1 = [3,5,1,6,2,9,8,None,None,7,4]
    nl2 = [3,5,1,6,7,4,2,None,None,None,None,None,None,9,8]

    bi1 = BiTreeHelper(nl1)
    bi1.inorder_traversal_print() # 657243918
    bi2 = BiTreeHelper(nl2)
    bi2.inorder_traversal_print() # 657341928

    s = Solution()
    print(s.leafSimilar(bi1.root, bi2.root)) # True

虽然说东哥的算法小抄 p258有关于层次遍历反序列化的解法，但是感觉过于tricky，不容易推广到多叉树。

错误处理部分我基本没写，希望以后有机会补上吧。

---

我总认为还有一些地方能修改得更优雅，大伙给点批评吧，求求了QAQ。