二叉树的实现(补充)

二叉树的实现(补充)

本次实现的二叉树包括二叉树的先序遍历，中序遍历和后序遍历以及二叉树的层序遍历，还包括二叉树的高度，叶子节点以及反转二叉树

二叉树的层序遍历依然是使用Python内置的deque实现一个队列，根据队列先进先出(FIFO)的性质，先把二叉树的根节点放入队列中，判断队列是否为空，如果不为空，则弹出一个元素，打印该元素的值，如果该元素有左孩子，则把左孩子入队，如果有右孩子，则把有孩子入队

代码:

from collections import deque


class Queue:  # 借助内置的 deque 我们可以迅速实现一个 Queue
    def __init__(self):
        self._elem = deque()

    def append(self, value):
        return self._elem.append(value)

    def pop(self):
        return self._elem.popleft()

    def empty(self):
        return len(self._elem) == 0


class BTree(object):
    def __init__(self, data=None, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right

    def preorder(self):
        if self.data is not None:
            print(self.data, end=',')
        if self.left is not None:
            self.left.preorder()
        if self.right is not None:
            self.right.preorder()

    def midorder(self):
        if self.left is not None:
            self.left.midorder()
        if self.data is not None:
            print(self.data, end=',')
        if self.right is not None:
            self.right.midorder()

    def postorder(self):
        if self.left is not None:
            self.left.postorder()
        if self.right is not None:
            self.right.postorder()
        if self.data is not None:
            print(self.data, end=',')

    def levelorder(self):

        # 返回某个节点的左孩子
        def LChild_Of_Node(node):
            return node.left if node.left is not None else None

        # 返回某个节点的右孩子
        def RChild_Of_Node(node):
            return node.right if node.right is not None else None

        # 层序遍历列表
        level_order = []
        # 是否添加根节点中的数据
        if self.data is not None:
            level_order.append([self])

        # 二叉树的高度
        height = self.height()
        if height >= 1:
            # 对第二层及其以后的层数进行操作, 在level_order中添加节点而不是数据
            for _ in range(2, height + 1):
                level = []  # 该层的节点
                for node in level_order[-1]:
                    # 如果左孩子非空，则添加左孩子
                    if LChild_Of_Node(node):
                        level.append(LChild_Of_Node(node))
                    # 如果右孩子非空，则添加右孩子
                    if RChild_Of_Node(node):
                        level.append(RChild_Of_Node(node))
                # 如果该层非空，则添加该层
                if level:
                    level_order.append(level)

            # 取出每层中的数据
            for i in range(0, height):  # 层数
                for index in range(len(level_order[i])):
                    level_order[i][index] = level_order[i][index].data

        return level_order

    def height(self):
        if self.data is None:
            return 0
        elif self.left is None and self.right is None:
            return 1
        elif self.left is None and self.right is not None:
            return 1 + self.left.height()
        elif self.left is not None and self.right is None:
            return 1 + self.left.height()
        else:
            return 1 + max(self.left.height(), self.right.height())

    def leaves(self):
        if self.data is None:
            return None
        elif self.left is None and self.right is None:
            print(self.data, end=',')
        elif self.left is None and self.right is not None:
            self.right.leaves()
        elif self.left is not None and self.right is None:
            self.left.leaves()
        else:
            self.left.leaves()
            self.right.leaves()

    # 反转二叉树
    def reverse(self):
        if self.data is not None:
            if self.left and self.right:
                self.left, self.right = self.right, self.left
                self.left.reverse()
                self.right.reverse()

    # @staticmethod
    # def layer_trav(subtree):
    #     cur_nodes = [subtree]  # current layer nodes
    #     next_nodes = []
    #     while cur_nodes or next_nodes:
    #         for node in cur_nodes:
    #             print(node.data, end=',')
    #             if node.left:
    #                 next_nodes.append(node.left)
    #             if node.right:
    #                 next_nodes.append(node.right)
    #         cur_nodes = next_nodes  # 继续遍历下一层
    #         next_nodes = []

    @staticmethod
    def layer_trav(subtree):
        q = Queue()
        q.append(subtree)
        while not q.empty():
            node = q.pop()
            print(node.data, end=',')
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)


if __name__ == '__main__':
    right_tree = BTree(6)
    right_tree.left = BTree(2)
    right_tree.right = BTree(4)

    left_tree = BTree(5)
    left_tree.left = BTree(1)
    left_tree.right = BTree(3)

    tree = BTree(11)
    tree.left = left_tree
    tree.right = right_tree

    left_tree = BTree(7)
    left_tree.left = BTree(3)
    left_tree.right = BTree(4)

    right_tree = tree  # 增加新的变量
    tree = BTree(18)
    tree.left = left_tree
    tree.right = right_tree
    tree.root = tree

    print('先序遍历为:')
    tree.preorder()
    print('
')

    print('后序遍历为:')
    tree.postorder()
    print('
')

    print('中序遍历为:')
    tree.midorder()
    print('
')

    print('层序遍历为:')
    level_order = tree.levelorder()
    tree.layer_trav(tree)
    print('
')
    print(level_order)

    print('叶子节点为:')
    tree.leaves()
    print('
')

    print('树的高度为:')
    print(tree.height())
    print('
')

    print('反转二叉树')
    tree.reverse()
    print('先序遍历')
    tree.preorder()
    print('
')
    print('层序遍历')
    tree.layer_trav(tree)