Python二叉树广度、深度优先遍历和前、中、后序遍历

Python二叉树广度、深度优先遍历和前、中、后序遍历

class Node:
    def __init__(self, elem=None, lchild=None, rchild=None):
        '''节点'''
        self.elem = elem
        self.lchild = lchild
        self.rchild = rchild

class BinaryTree:
    '''二叉树'''
    def __init__(self):
        self.root = None

    def add(self, elem):
        '''添加节点'''
        node = Node(elem)
        if self.root is None:        # 若树为空，则对根节点赋值
            self.root = node
        else:
            queue = []
            queue.append(self.root)
            while queue:             # 层次遍历
                cur = queue.pop(0)   # 出队
                if cur.lchild is None:
                    cur.lchild = node
                    return
                elif cur.rchild is None:
                    cur.rchild = node
                    return
                else:                # 左右孩子都不为空，入队
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)

    def breadth_travel(self):
        '''广度优先遍历、层次遍历（队列）'''
        if self.root is None:
            return
        queue = [self.root]                     # 根节点入队
        while queue:
            cur_node = queue.pop(0)             # 出队
            print(cur_node.elem, end=' ')
            if cur_node.lchild is not None:     # 左孩子不为空，则入队
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:     # 右孩子不为空，则入队
                queue.append(cur_node.rchild)
    
    def depth_travel(self):
        '''深度优先遍历、前序遍历（栈）'''
        if self.root is None:
            return 
        stack = [self.root]                     # 根节点入栈
        while stack:
            cur_node = stack.pop()              # 出栈
            print(cur_node.elem, end=' ')
            if cur_node.rchild is not None:     # 右孩子不为空，则入栈
                stack.append(cur_node.rchild) 
            if cur_node.lchild is not None:     # 左孩子不为空，则入栈
                stack.append(cur_node.lchild)

    def pre_order(self, node):
        '''前序遍历、深度优先遍历（递归）'''
        if node is None:
            return
        print(node.elem, end=' ')
        self.pre_order(node.lchild)
        self.pre_order(node.rchild)

    def in_order(self, node):
        '''中序遍历（递归）'''
        if node is None:
            return
        self.in_order(node.lchild)
        print(node.elem, end=' ')
        self.in_order(node.rchild)

    def post_order(self, node):
        '''后序遍历（递归）'''
        if node is None:
            return
        self.post_order(node.lchild)
        self.post_order(node.rchild)
        print(node.elem, end=' ')

1. 创建二叉树、添加节点

bt = BinaryTree()    # 创建二叉树
bt.add(0)            # 添加节点
bt.add(1)
bt.add(2)
bt.add(3)
bt.add(4)
bt.add(5)
bt.add(6)
bt.add(7)
bt.add(8)
bt.add(9)

2. 广度优先遍历、层次遍历（队列）

bt.breadth_travel() 

0 1 2 3 4 5 6 7 8 9

3. 深度优先遍历、前序遍历（栈）

bt.depth_travel()

0 1 3 7 8 4 9 2 5 6

4. 前序遍历、深度优先遍历（递归）

bt.pre_order(bt.root)

0 1 3 7 8 4 9 2 5 6 

5. 中序遍历（递归）

bt.in_order(bt.root)

7 3 8 1 9 4 0 5 2 6

6. 后序遍历（递归）

bt.post_order(bt.root)

7 8 3 9 4 1 5 6 2 0