Interview often test algorithm (two) - binary tree traversal [7 kinds]

Binary tree structure

class Node(object):
    """节点类"""

    def __init__(self, value=None, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right


class Tree(object):
    """二叉树类"""

    def __init__(self):
        """初始化树类的根节点和遍历队列"""
        self.root = Node()
        self.tree_queue = []  # 叶子结点的数据

    def add(self, value):
        """添加数据构造函数"""
        node = Node(value)
        if self.root.value is None:  # 树为空则进行节点的添加
            self.root = node
            self.tree_queue.append(node)
        else:
            cur_node = self.tree_queue[0]  # 获取当前的根节点
            if cur_node.left is None:  # 左子树为空则进行添加
                cur_node.left = node
                self.tree_queue.append(node)
            else:  # 有字数为空则加入
                cur_node.right = node
                self.tree_queue.append(node)
                self.tree_queue.pop(0)  # 当前节点分配完成，退出队列


def main():
    tree = Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)
    return tree


if __name__ == '__main__':
    tree = main()
    print(tree)

Preorder traversal

import 二叉树的构造 as tree_con


def pre_order(root):
    """递归实现树的前序遍历"""
    if root is None:
        return
    print(root.value, end="\t")
    pre_order(root.left)
    pre_order(root.right)


def pre_order_stack(root):
    """非递归实现树的前序遍历"""
    if root is None:
        return
    cur_node = root
    pre_stack = []
    while pre_stack or cur_node:
        while cur_node:
            print(cur_node.value, end="\t")
            pre_stack.append(cur_node)
            cur_node = cur_node.left
        cur_node = pre_stack.pop()
        cur_node = cur_node.right
    print()


if __name__ == '__main__':
    tree = tree_con.main()
    print(tree)
    # pre_order(tree.root)
    pre_order_stack(tree.root)

Preorder

import 二叉树的构造 as tree_con


def in_order(root):
    """递归实现树的中序遍历"""
    if root is None:
        return
    in_order(root.left)
    print(root.value, end="\t")
    in_order(root.right)


def in_order_stack(root):
    """非递归实现树的中序遍历"""
    if root is None:
        return
    cur_node = root
    in_stack = []
    while in_stack or cur_node:
        while cur_node:
            in_stack.append(cur_node)
            cur_node = cur_node.left
        cur_node = in_stack.pop()
        print(cur_node.value, end="\t")
        cur_node = cur_node.right
    print()


if __name__ == '__main__':
    tree = tree_con.main()
    print(tree)
    print([ele.value for ele in tree.tree_queue])
    in_order_stack(tree.root)
    in_order(tree.root)

Postorder

import 二叉树的构造 as tree_con


def post_order(root):
    """递归实现树的后序遍历"""
    if root is None:
        return
    post_order(root.left)
    post_order(root.right)
    print(root.value, end="\t")


def post_order_stack(root):
    """非递归实现树的后序遍历"""
    if root is None:
        return
    cur_node = root
    post_stack1 = []
    post_stack2 = []
    post_stack1.append(cur_node)
    while post_stack1:
        cur_node = post_stack1.pop()
        if cur_node.left:
            post_stack1.append(cur_node.left)
        if cur_node.right:
            post_stack1.append(cur_node.right)
        post_stack2.append(cur_node)
    while post_stack2:
        print(post_stack2.pop().value, end="\t")
    print()


if __name__ == '__main__':
    tree = tree_con.main()
    print(tree)
    # print([ele.value for ele in tree.tree_queue])
    post_order_stack(tree.root)
    post_order(tree.root)

Traverse the level, breadth-first traversal

import 二叉树的构造 as tree_con


def level_order(root):
    if root is None:
        return
    level_queue = [root]
    while level_queue:
        cur_node = level_queue.pop(0)
        print(cur_node.value, end="\t")
        if cur_node.left:
            level_queue.append(cur_node.left)
        if cur_node.right:
            level_queue.append(cur_node.right)
    print()


if __name__ == '__main__':
    tree = tree_con.main()
    print(tree)
    level_order(tree.root)