python---二叉树遍历

重学。

# coding = utf-8

# 二叉树遍历
class Node:
    """节点类"""
    def __init__(self, element=None, left_child=None, right_child=None):
        self.element = element
        self.left_child = left_child
        self.right_child = right_child

class Tree:
    """树类"""
    def __init__(self):
        self.root = Node()
        self.tree_queue = []

    def add(self, element):
        """为树添加节点"""
        node = Node(element)
        if self.root.element is None:
            self.root = node
            self.tree_queue.append(self.root)
        else:
            tree_node = self.tree_queue[0]
            if tree_node.left_child is None:
                tree_node.left_child = node
                self.tree_queue.append(tree_node.left_child)
            else:
                tree_node.right_child = node
                self.tree_queue.append(tree_node.right_child)
                self.tree_queue.pop(0)

    def front_recursion(self, root):
        """利用递归实现树的先序遍历"""
        if root is None:
            return
        print(root.element, end=' ')
        self.front_recursion(root.left_child)
        self.front_recursion(root.right_child)

    def middle_recursion(self, root):
        """利用递归实现树的中序遍历"""
        if root is None:
            return
        self.middle_recursion(root.left_child)
        print(root.element, end=' ')
        self.middle_recursion(root.right_child)

    def later_recursion(self, root):
        """利用递归实现树的后序遍历"""
        if root is None:
            return
        self.later_recursion(root.left_child)
        self.later_recursion(root.right_child)
        print(root.element, end=' ')

    def front_stack(self, root):
        """利用堆栈实现树的先序遍历"""
        if root is None:
            return
        tree_stack = []
        node = root
        while node or tree_stack:
            while node:
                print(node.element, end=' ')
                tree_stack.append(node)
                node = node.left_child
            node = tree_stack.pop()
            node = node.right_child

    def middle_stack(self, root):
        """利用堆栈实现树的中序遍历"""
        if root is None:
            return
        tree_stack = []
        node = root
        while node or tree_stack:
            while node:
                tree_stack.append(node)
                node = node.left_child
            node = tree_stack.pop()
            print(node.element, end=' ')
            node = node.right_child

    def later_stack(self, root):
        """利用堆栈实现树的后序遍历"""
        if root is None:
            return
        tree_stack_a = []
        tree_stack_b = []
        node = root
        tree_stack_a.append(node)
        while tree_stack_a:
            node = tree_stack_a.pop()
            if node.left_child:
                tree_stack_a.append(node.left_child)
            if node.right_child:
                tree_stack_a.append(node.right_child)
            tree_stack_b.append(node)
        while tree_stack_b:
            print(tree_stack_b.pop().element, end=' ')

    def level_queue(self, root):
        """利用队列实现树的层次遍历"""
        if root is None:
            return
        tree_queue = []
        node = root
        tree_queue.append(node)
        while tree_queue:
            node = tree_queue.pop(0)
            print(node.element, end=' ')
            if node.left_child is not None:
                tree_queue.append(node.left_child)
            if node.right_child is not None:
                tree_queue.append(node.right_child)

if __name__ == '__main__':
    elem_s = range(10)
    # 新建一个二叉树对象
    tree = Tree()
    for elem in elem_s:
        tree.add(elem)

    print('广度优先遍历---队列实现层次遍历:')
    tree.level_queue(tree.root)
    print('\n深度优先遍历---递归实现先序遍历:')
    tree.front_recursion(tree.root)
    print('\n深度优先遍历---递归实现中序遍历:')
    tree.middle_recursion(tree.root)
    print('\n深度优先遍历---递归实现后序遍历:')
    tree.later_recursion(tree.root)
    print('\n深度优先遍历---堆栈实现先序遍历:')
    tree.front_stack(tree.root)
    print('\n深度优先遍历---堆栈实现中序遍历:')
    tree.middle_stack(tree.root)
    print('\n深度优先遍历---堆栈实现后序遍历:')
    tree.later_stack(tree.root)

C:\Users\Sahara\.virtualenvs\test\Scripts\python.exe C:/Users/Sahara/PycharmProjects/test/python_search.py
广度优先遍历---队列实现层次遍历:

深度优先遍历---递归实现先序遍历:

深度优先遍历---递归实现中序遍历:

深度优先遍历---递归实现后序遍历:

深度优先遍历---堆栈实现先序遍历:

深度优先遍历---堆栈实现中序遍历:

深度优先遍历---堆栈实现后序遍历:

Process finished with exit code