二叉树的遍历及其代码实现

二叉树的遍历及其代码实现

前言

二叉树的遍历及其代码实现。

一、二叉树的遍历

二叉树的遍历分4种：前序遍历、中序遍历、后序遍历、层次遍历。
前序遍历：根左右
中序遍历：左根右
后序遍历：左右根

二、二叉树的遍历代码实现

1.递归写法

前序遍历、中序遍历、后序遍历的递归写法：

# -*- coding:utf-8 -*-
#@Time : 2020/12/30 0030 下午 17:04
#@Author: 疏窗泛影
#@File : BinaryTree.py

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

def create_binary_tree(input_list=[]):
    """
    构建二叉树
    :param input_list: 
    :return: 
    """""
    if input_list is None or len(input_list) == 0:
        return None
    data = input_list.pop(0)
    if data is None:
        return None
    node = TreeNode(data)
    node.left = create_binary_tree(input_list)
    node.right = create_binary_tree(input_list)
    return node

def pre_order_traversal(node):
    """
    前序遍历
    :param node:
    :return:
    """
    if node is None:
        return
    print(node.data)
    pre_order_traversal(node.left)
    pre_order_traversal(node.right)
    return node

def in_order_traversal(node):
    """
    中序遍历
    :param node:
    :return:
    """
    if node is None:
        return
    in_order_traversal(node.left)
    print(node.data)
    in_order_traversal(node.right)
    return node

def post_order_traversal(node):
    """
    后序遍历
    :param node:
    :return:
    """
    if node is None:
        return
    post_order_traversal(node.left)
    post_order_traversal(node.right)
    print(node.data)
    return node

if __name__ == '__main__':
    my_input_list = list([2,4,8,7,9,5,6,None,3,2,4,6,None])
    root = create_binary_tree(my_input_list)
    print("前序遍历：")
    pre_order_traversal(root)
    print("中序遍历：")
    in_order_traversal(root)
    print("后序遍历：")
    post_order_traversal(root)

1.非递归写法

非递归写法借助栈是实现，利用栈的回溯特性。其中非递归后序遍历借用双栈。

def pre_order_traversal_with_stack(node):
    """
    非递归前序遍历 借助栈实现
    :param nade:
    :return:
    """
    stack = []
    while node is not None or len(stack) > 0:
        while node is not None:
            print(node.data)
            stack.append(node)
            node = node.left
        if len(stack) > 0:
            node = stack.pop()
            node = node.right

def in_order_traversal_with_stack(node):
    """
    非递归中序遍历 借助栈实现
    :param nade:
    :return:
    """
    stack = []
    while node is not None or len(stack) > 0:
        while node is not None:
            stack.append(node)
            node = node.left
        if len(stack) > 0:
            node = stack.pop()
            print(node.data)
            node = node.right

def post_order_traversal_with_stack(node):
    """
    非递归后序遍历 借助栈实现
    :param nade:
    :return:
    """
    stack1 = []
    stack2 = []
    stack1.append(node)
    while stack1:
        node = stack1.pop()
        stack2.append(node)
        if node.left:
            stack1.append(node.left)
        if node.right:
            stack1.append(node.right)
    while stack2:
        print(stack2.pop().data)
    return

层次遍历

def level_order_travarsal(node):
    """
    层次遍历
    :param node:
    :return:
    """
    queue = Queue()
    queue.put(node)
    while not queue.empty():
        node = queue.get()
        print(node.data)
        if node.left is not None:
            queue.put(node.left)
        if node.right is not None:
            queue.put(node.right)