二叉树基础-七种遍历算法python实现

二叉树是数据结构的基础及要点，今日简单整理了几种遍历算法，并用python实现，算法如下

二叉树的创建

# binary_tree_build.py
class Node(object):
    def __init__(self, value, left_child=None, right_child=None):
        self.value = value
        self.left_child = left_child
        self.right_child = right_child


class Tree(object):
    def __init__(self):
        self.root = None
        self.__node_add_queen = []

    def add(self, node):
        if not self.root:
            self.root = node
        elif not self.__node_add_queen[0].left_child:
            self.__node_add_queen[0].left_child = node
        else:
            self.__node_add_queen[0].right_child = node
            self.__node_add_queen.pop(0)
        self.__node_add_queen.append(node)

二叉树的遍历

1. 先序遍历-递归

def pre_order_traverse(node):
    if not node:
        return
    # do something
    print node.value
    pre_order_traverse(node.left_child)
    pre_order_traverse(node.right_child)

2. 先序遍历-非递归

def pre_order_with_stack(node):
    traverse_stack = [node]
    while traverse_stack:
        current_node = traverse_stack.pop()
        # do something
        print current_node.value
        if current_node.right_child:
            traverse_stack.append(current_node.right_child)
        if node.left_child:
            traverse_stack.append(current_node.left_child)

3. 中序遍历-递归

def in_order_traverse(node):
    if not node:
        return
    in_order_traverse(node.left_child)
    # do something
    print node.value
    in_order_traverse(node.right_child)

4. 中序遍历-非递归

def in_order_with_stack(node):
    traverse_stack = []
    current_node = node
    while current_node or traverse_stack:
        while current_node:
            traverse_stack.append(current_node)
            current_node = current_node.left_child

        current_node = traverse_stack.pop()
        # do something
        print current_node.value
        current_node = current_node.right_child

5. 后序遍历

def post_order_traverse(node):
    if not node:
        return
    post_order_traverse(node.left_child)
    post_order_traverse(node.right_child)
    # do something
    print node.value

6. 后序遍历-非递归

def post_order_with_stack(node):
    pre_traverse_stack = [node]
    post_traverse_stack = []
    while pre_traverse_stack:
        current_node = pre_traverse_stack.pop()
        post_traverse_stack.append(current_node)
        if current_node.left_child:
            pre_traverse_stack.append(current_node.left_child)
        if current_node.right_child:
            pre_traverse_stack.append(current_node.right_child)

    while post_traverse_stack:
        # do something
        print post_traverse_stack.pop()

7. 层次遍历

def traverse_by_layer(node):
    traverse_list = [node]
    while traverse_list:
        current_node = traverse_list.pop(0)
        if current_node.left_child:
            traverse_list.append(current_node)
        if current_node.right_child:
            traverse_list.append(current_node.right_child)
        # do something
        print current_node.value

后续会有树和图相关知识点的算法实现文章讲解，喜欢的可以关注一下