二叉树 | 列表转树 | 树遍历：前序，中序，后序，层次 | N叉树

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

1、将列表型二叉树还原成树结构

ls=[5,4,8,11,None,13,4,7,2,None,None,None,1]
ls.reverse()
def reate_binaryTree(ls,ls1=[],ls2=[]):
    beg = TreeNode(ls.pop())
    ls1.append(beg)
    while ls:
        for root in ls1:
            if root.val==None:continue
            left = TreeNode(ls.pop())
            right = TreeNode(ls.pop())
            root.left=left
            root.right=right
            ls2+=[left,right]
        ls1=ls2[:]
        ls2.clear()
    return beg

为了使得可以使用pop()，于是在最开始对ls进行一次反序。

1.1 列表转树的递归法

        def rdeserialize(l):
            if l[0] == 'None':
                l.pop(0)
                return None
                
            root = TreeNode(l[0])
            l.pop(0)
            root.left = rdeserialize(l)
            root.right = rdeserialize(l)
            return root

2、树遍历

2.1 前序遍历

前序遍历（preorder）：先访问根节点，再递归地前序访问左子树、最后前序访问右子树；实践：144. 二叉树的前序遍历

def look(root):
    if root:
        print(root.val)
        look(root.left)
        look(root.right)
# look(root)

对上例进行遍历(将print语句修改为print(root.val,end=' '))结果：
5 4 11 7 2 None 8 13 None None 4 None 1

def look(root):
    if root:
        if root.val:
            print(root.val,end=' ')
            look(root.left)
            look(root.right)
look(root)

结果：5 4 11 7 2 8 13 4 1

2.1.1 前序遍历的翻转

        def look(r):
            if r:
                look(r.right)
                look(r.left)
                ls.append(r.val)

2.1.2 N叉树的前序遍历

# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
     	# children 是列表类型。

class Solution:
    # ls=[]
    def preorder(self, root: 'Node') -> List[int]:
        ls=[]
        def BFS(root):
            if not root:return 
            ls.append(root.val)
            if not root.children:return ls
            for i in root.children:
                BFS(i)
            return ls
        return BFS(root)

把可变容器类型直接绑定到类属性或者放到方法里如:def preorder(self, root: 'Node', ls=[])在做这道题时都会导致容器不进行初始化。
——
写着，突然想到可以把容器放到类的初始化里，试一试。

class Solution:
    def __init__(self):
        self.ls=[]
    def preorder(self, root: 'Node') -> List[int]:
        if not root:return 
        self.ls.append(root.val)
        if not root.children:return self.ls
        for i in root.children:
            self.preorder(i)
        return self.ls

也行。

2.2 中序遍历

中序遍历（inorder）：先递归地中序访问左子树，再访问根节点，最后中序访问右子树；实践：94. 二叉树的中序遍历

def look(root):
    if root:
        if root.val:
            look(root.left)
            print(root.val,end=' ')
            look(root.right)

结果：7 11 2 4 5 13 8 4 1

中序遍历二叉搜索树是递增数组。

2.3 后序遍历

后序遍历（postorder）：先递归地后序访问左子树，再后序访问右子树，最后访问根节点。实践：145. 二叉树的后序遍历

def look(root):
    if root:
        if root.val:
            look(root.left)
            look(root.right)
            print(root.val,end=' ')

结果：7 2 11 4 13 1 4 8 5

2.3.2 N叉树的后序遍历

class Solution:
    def __init__(self):
        self.ls=[]
    def postorder(self, root: 'Node') -> List[int]:
        if not root:return 
        for i in root.children:
            self.postorder(i)
        self.ls.append(root.val)
        return self.ls

2.4 层次遍历

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:return []
        q = [root]
        result = []
        while q:
            res= []
            for i in range(len(q)):
                i=q.pop(0)
                res.append(i.val)
                if i.left:q.append(i.left)
                if i.right:q.append(i.right)
            result.append(res)
        return result

2.4.1 N叉树的层次遍历

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root:return []
        ls=[root]
        res=[]
        while ls:
            tmp=[]
            for i in range(len(ls)):
                i=ls.pop(0)
                ls.extend(i.children)
                tmp.append(i.val)
            res.append(tmp)
        return res