Python 数据结构——深度遍历 二叉树（先、中、后序

树的遍历

即深度遍历，描述的就是 在最基本的三节点的树，节点的遍历顺序如下
      A
   /     \
  B        C

• 先序遍历：根节点优先 A->B->C
• 中序遍历：根节点中间 B->A->C
• 后续遍历：根节点最后 B->C->A
• 在每次遍历时，根节点都会变，就相当于遍历一个新的子树
  递归方法可以解决

# -*- coding:utf-8 -*-
"""
作者：bug君
日期：2023年 04月 05日
标题：遍历二叉树
作用：
思路：利用  广度优先 向树中添加节点，广度优先利用到了队列的数据结构思想
"""


class Node:
    def __init__(self, item):
        self.elem = item
        self.lchild = None
        self.rchild = None


class Tree:
    def __init__(self):
        self.root = None

    def add(self, item):  # 用于向树中 添加一个元素
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]  # 用列表代替queue操作
        while queue:
            curNode = queue.pop(0)
            if curNode.lchild is None:
                curNode.lchild = node
                return
            else:
                queue.append(curNode.lchild)
            if curNode.rchild is None:
                curNode.rchild = node
                return
            else:
                queue.append(curNode.rchild)

    def addNodes(self, NewDatas):  # 用于需要添加多个元素节点的情况
        if self.root is None:
            self.root = Node(NewDatas.pop(0))
        queue = [self.root]
        rank = True
        while NewDatas:  # 循环结束的条件为 添加列中无元素
            curNode = queue.pop(0)  # 需要遍历到，某个没有子节点的位置
            if rank:  # rank表示节点的更新条件
                NewDate = Node(NewDatas.pop(0))
                rank = False
            if curNode.lchild is None:
                curNode.lchild = NewDate
                queue.append(NewDate)
                if not NewDatas:  # 防治措施：当添加列中无元素时，退出循环
                    break
                NewDate = Node(NewDatas.pop(0))  # 当左节点被添加后， 更新待添加节点
                rank = True  # 此时的情况
            else:
                queue.append(curNode.lchild)

            if curNode.rchild is None:
                curNode.rchild = NewDate
                queue.append(NewDate)
                rank = True
            else:
                queue.append(curNode.rchild)

    def breadth_travel(self):  # 广度遍历
        if self.root is None:  # 默认树中有元素，防治措施
            print('树中无元素，无法遍历')
            return
        queue = [self.root]

        while queue:
            curNode = queue.pop(0)
            print(curNode.elem)
            if curNode.lchild is not None:
                queue.append(curNode.lchild)
            if curNode.rchild is not None:
                queue.append(curNode.rchild)

    def preorder(self, node):
        '''
        先序遍历
        '''
        if node is None:
            return
        print(node.elem, end='、')
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self, node):
        '''
        中序遍历
        '''
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem, end='、')
        self.inorder(node.rchild)

    def lastorder(self, node):
        '''
        后序遍历
        '''
        if node is None:
            return
        self.lastorder(node.lchild)
        self.lastorder(node.rchild)
        print(node.elem, end='、')




if __name__ == '__main__':
    tree = Tree()
    print("第0次遍历")
    tree.breadth_travel()
    tree.add(1)
    print("第1次遍历")
    tree.breadth_travel()

    lis = [2, 3, 4, 5, 6, 7]
    tree.addNodes(lis)
    print("第2次遍历")
    tree.breadth_travel()

    print('先序遍历')
    tree.preorder(tree.root)
    print()

    print('中序遍历')
    tree.inorder(tree.root)
    print()

    print('后序遍历')
    tree.lastorder(tree.root)