数据结构：python递归实现二叉树前中后遍历+层次遍历

 

前中后遍历的基本解释

顺序的遍历是按照根节点的先后访问顺序制定的。
（根->左->右）前序遍历：首先访问根结点，然后遍历左子树，最后遍历右子树
（左->根->右）中序遍历：首先遍历左子树，然后访问根节点，最后遍历右子树
（左->右->根）后序遍历：首先遍历左子树，然后遍历右子树，最后访问根节点

链表代码解释前中后遍历和层次遍历

#!/usr/bin/env python
# -*- encoding: utf-8 -*-


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

#
# class Solution:
#     def preorderTraversal(self, root: TreeNode) -> List[int]:
#
#         def PreOrder(self, root):
#             '''打印二叉树(先序)'''
#             if root == None:
#                 return
#             print(root.val, end=' ')
#             self.PreOrder(root.left)
#             self.PreOrder(root.right)
#
#         def InOrder(self, root):
#             '''中序打印'''
#             if root == None:
#                 return
#             self.InOrder(root.left)
#             print(root.val, end=' ')
#             self.InOrder(root.right)
#
#         def BackOrder(self, root):
#             '''后序打印'''
#             if root == None:
#                 return
#             self.BacOrder(root.left)
#             self.BacOrder(root.right)
#             print(root.val, end=' ')


class BinaryTreeNode(object):
    def __init__(self, data=None, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right


class BinaryTree(object):
    def __init__(self, root=None):
        self.root = root

    def is_empty(self):
        return self.root == None

    # 先序遍历
    def preOrder(self, BinaryTreeNode):
        if BinaryTreeNode == None:
            return

        print(BinaryTreeNode.data, '\t', end='')
        self.preOrder(BinaryTreeNode.left)
        self.preOrder(BinaryTreeNode.right)

    # 中序遍历
    def inOrder(self, BTNode):
        if BTNode == None:
            return

        self.inOrder(BTNode.left)
        print(BTNode.data, '\t', end='')
        self.inOrder(BTNode.right)

    # 后序遍历
    def postOrder(self, BTNode):
        if BTNode == None:
            return

        self.postOrder(BTNode.left)
        self.postOrder(BTNode.right)
        print(BTNode.data, '\t', end='')

    # 层次遍历
    def levelOrder(self, BinaryTreeNode):
        if BinaryTreeNode is None:
            return
        my_queue = []
        node = BinaryTreeNode
        my_queue.append(node)
        while my_queue:
            node = my_queue.pop(0)
            print(node.data, '\t', end='')
            if node.left:
                my_queue.append(node.left)
            if node.right:
                my_queue.append(node.right)

        # # 层次遍历
        # def levelOrder(self, BinaryTreeNode):
        #     """
        #     :type BinaryTreeNode: TreeNode
        #     :rtype: List[List[int]]
        #     """
        #
        #     def helper(BinaryTreeNode, level):
        #         if BinaryTreeNode == None:
        #             return
        #         else:
        #             sol[level - 1].append(BinaryTreeNode.data)
        #             if len(sol) == level:  # 遍历到新层时，只有最左边的结点使得等式成立
        #                 sol.append([])
        #             helper(BinaryTreeNode.left, level + 1)
        #             helper(BinaryTreeNode.right, level + 1)
        #
        #     sol = [[]]
        #     helper(BinaryTreeNode, 1)
        #     print(sol[:-1])
        #     for i in sol:
        #         for j in i:
        #             print(j, '\t', end='')


if __name__ == '__main__':
    n001 = BinaryTreeNode(data='D')
    n002 = BinaryTreeNode(data='E')
    n003 = BinaryTreeNode(data='F')
    n004 = BinaryTreeNode(data='B', left=n001, right=n002)
    n005 = BinaryTreeNode(data='C', left=n003, right=None)
    root = BinaryTreeNode(data='A', left=n004, right=n005)
    obj = BinaryTree(root)

    print('层序遍历:')
    obj.levelOrder(obj.root)
    print('\n先序遍历:')
    obj.preOrder(obj.root)
    print('\n中序遍历:')
    obj.inOrder(obj.root)
    print('\n后序遍历:')
    obj.postOrder(obj.root)

    # 层序遍历:
    # A 	B 	C 	D 	E 	F
    # 先序遍历:
    # A 	B 	D 	E 	C 	F
    # 中序遍历:
    # D 	B 	E 	A 	F 	C
    # 后序遍历:
    # D 	E 	B 	F 	C 	A

数组的前中后遍历

参考以上的基础上

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        def preorder(root: TreeNode):
            if not root:
                return
            res.append(root.val)
            preorder(root.left)
            preorder(root.right)
        
        res = list()
        preorder(root)
        return res

数组的层序遍历

二叉树的层序遍历：遍历每一层的结果取出来作为列表， 如下
原始： [3,9,20,null,null,15,7],
结果：[[3],[9,20],[15,7]]
思路： 一个队列（输入）， 两个列表处理（一个总列表，一个临时列表）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:

        if root is None:
            return

        res = []
        my_queue = [root]
        while my_queue:
            current_layer_len = len(my_queue)
            layer = []
            for _ in range(current_layer_len):
                cur_node = my_queue.pop(0)
                layer.append(cur_node.val)
                print(cur_node.val, '\t', end='')

                if cur_node.left:
                    my_queue.append(cur_node.left)
                if cur_node.right:
                    my_queue.append(cur_node.right)
            res.append(layer)

        return res

　　

 数组的中序遍历

中序迭代遍历
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        stack, node = [], root

        if not root: return [] # 基本情况直接返回
        while stack or node:
            while node:
                stack.append(node) # 先把节点放到栈里面
                node = node.left # 看它有没有左分支，如果有，这个while循环会走到底
            node = stack.pop() # 把根pop出来，把他的值放到list里面
            res.append(node.val) 
            node = node.right # 看他有没有右分支，然后重复
        return res
        

递归遍历
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []

        if not root: return [] # 基本情况直接返回
        def check(node):
            if not node: return # 走到了根，返回
            check(node.left) # 查看左边，直到走到根
            res.append(node.val) # 把根值放进去
            check(node.right) # 开始检查右边

        check(root)
        return res

　　

求二叉树的最大深度

class Solution:
    def maxDepth(self, root):
        if root is None:
            return 0
        else:
            l = self.maxDepth(root.left)
            r = self.maxDepth(root.left)
            return max(l, r) + 1

　　

翻转二叉树

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root
        
        left = self.invertTree(root.left)
        right = self.invertTree(root.right)
        root.left, root.right = right, left
        return root