python数据结构与算法:二叉树

学习黑马程序员数据结构与算法笔记

二叉树

class Node:
    """
    节点定义
    """

    def __init__(self, element):
        """
        初始化
        :param element:
        """
        self.element = element  # 元素
        self.left_child = None  # 左节点
        self.right_child = None  # 右节点


class Tree:
    def __init__(self, node: Node = None):
        self._root = node

    def add(self, item):
        node = Node(item)
        if self._root is None:  # 必须保证self._root != None
            self._root = node
            return

        # self._root is not None
        queue = [self._root]  # 按照队列的方式的操作列表：尾部插入，头部读出

        while queue:  # 只要queue不是空，那么就可以一直循环
            cur_node = queue.pop(0)

            # 左子节点=None，那么就将新节点添加到此处
            if cur_node.left_child is None:
                cur_node.left_child = node
                return
            else:  # 左子节点不是空，那么，就将左子节点添加到队列中，方便下次处理
                queue.append(cur_node.left_child)

            # 右子节点=None，将节点添加到此处
            if cur_node.right_child is None:
                cur_node.right_child = node
                return
            else:  # 右子节点不是None，将右子节点添加到队列中
                queue.append(cur_node.right_child)

    def return_root(self):
        return self._root

    def breath_travel(self):
        """
        广度遍历
        :return:
        """
        if self._root is None:
            return None

        queue = [self._root]  # 一个队列保存节点
        while queue:  # 只要队列中不是None，就一直循环
            cur_node = queue.pop(0)  # 弹出一个元素
            print(cur_node.element, end=' ')  # 打印元素
            if cur_node.left_child is not None:
                queue.append(cur_node.left_child)
            if cur_node.right_child is not None:
                queue.append(cur_node.right_child)

        print()  # 恢复正常打印设置
	
	#  =======================#
	#  深度遍历
	#  =======================#
    def preorder(self, node: Node):
        """
        先序遍历：根节点->左子树->右子树
        递归方法实现
        :param node:
        :return:
        """
        # 递归结束条件
        if node is None:  # 叶节点的子节点都是None，但是首先判断的是左子树
            return
        print(node.element, end=' ')
        self.preorder(node.left_child)  # 遍历左子树
        self.preorder(node.right_child)  # 遍历右子树

    def inorder(self, node: Node):
        """
        中序遍历：左子树->根节点->右子树
        :param node:
        :return:
        """
        if node is None:  # 当前节点是None，就返回
            return
        self.inorder(node.left_child)
        print(node.element, end=' ')
        self.inorder(node.right_child)

    def postorder(self, node: Node):
        """
        后序遍历：左子树->右子树->根节点
        :param node:
        :return:
        """
        if node is None:
            return
        self.postorder(node.left_child)
        self.postorder(node.right_child)
        print(node.element, end=' ')


if __name__ == '__main__':
    print()
    tree = Tree(Node(0))
    for v in range(1, 10):
        tree.add(v)

    print('breath_travel')
    tree.breath_travel()
    print("preorder")
    tree.preorder(tree.return_root())
    print("\ninorder")
    tree.inorder(tree.return_root())
    print("\npostorder")
    tree.postorder(tree.return_root())