python实现二叉树的添加,深度遍历和广度遍历

树的常用术语

1.节点的度: 一个节点含有的子节点的个数
2.树的度: 树结构中最大的节点的度, 最大的分支节点个数
3.叶节点: 度为零的节点, 没有子节点的末端节点
4.节点的层次: 从根开始, 根是第一层, 一次往下数
5.树的深度: 树中节点最大层次

二叉树的概念

• 二叉树是一种有序树,每个节点最多含有两个子节点
• 二叉树的分类:
  完全二叉树: 除了最下层,每一层的度数都最大
  满二叉树: 所有子节点都达到最满
  平衡二叉树: 任何节点的两棵子树的高度差不大于1
  二叉排列数 : 分支上的数据有一定的顺序

二叉树的遍历

把二叉树中的所有节点都访问一遍

• 深度优先: 沿着树的深度遍历树的节点, 有三种方法:
  - 先序遍历 根节点->左子树->右子树
  - 中序遍历 左子树->根节点->右子树
  - 后续遍历 左子树->右子树->根节点
• 广度优先: 从树的root根开始, 从上到下从左到右, 从水平的宽度上来遍历

python3 实现树的添加, 三种深度遍历和广度遍历

# 二叉树的用法


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


class Tree(object):
    # 树类
    def __init__(self):
        # 根节点是root
        self.root = None

    def add(self, elem):
        # 向树中添加节点
        # 先创建一个节点对象
        node = Node(elem)
        # 如果树是空的, 那么 root节点
        if self.root is None:
            self.root = node
            return

        # todo 直接放到列表中就可以, 用append添加的方式不行
        queue = [self.root]
        # 队列的方式, 遍历元素放入队列中
        # queue = queue.append(self.root)
        # 退出循环的条件, 队列是空的
        while queue:
            # 弹出队列的第一个元素
            cur_node = queue.pop(0)
            # 如果节点的左孩子是空的
            if cur_node.lchild is None:
                # 把元素放在该节点
                cur_node.lchild = node
                return
            # 节点的右孩子是空的
            elif cur_node.rchild is None:
                # 把元素放在该节点
                cur_node.rchild = node
                return
            else:
                # 左右海子都不为空, 添加到队列中继续判断
                queue.append(cur_node.lchild)
                # queue.append(cur_node.rchild)

    def breadth_travel(self):
        """利用队列实现树的层次遍历"""

        if self.root == None:
            return
        queue = []
        queue.append(self.root)

        while queue:
            node = queue.pop(0)
            print(node.elem)
            if node.lchild != None:
                queue.append(node.lchild)
            if node.rchild != None:
                queue.append(node.rchild)

    # 先序遍历 根 左 右
    def preorder(self, node):
        if node is None:
            return
        # 打印根节点, 
        print(node.elem)
        # 递归找出每一个节点, 左节点递归
        self.preorder(node.lchild)
        # 递归找出每一个节点,右节点递归
        self.preorder(node.rchild)

    # 中序遍历 左 根 右
    def inorder(self, node):
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem)
        self.inorder(node.rchild)

    # 后序遍历 左 右 根
    def backorder(self, node):
        if node is None:
            self.backorder(node.rchild)
            self.backorder(node.lchild)
            print(node.elem)

if __name__ == '__main__':
    tree = Tree()
    tree.add(9)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(5)
    tree.breadth_travel()
    print("----------")
    # 将根节点对象传递过去
    tree.inorder(tree.root)