python-数据结构（一）：二叉树的构建和遍历

树

二叉树的构建

1. 二叉树的构建主要是采用广度遍历的形式进行插入节点操作，期间采用一个队列（采用列表代替），将读取的到的节点放入队列中，然后遍历过的节点就可出队，该节点的子节点就进行入队操作。（root）代表根节点

在这里插入代码片class Node:
    """
    首先构建树形的节点框架
    存储数据：data，左右孩子节点：right,left
    """
    def __init__(self, data):
        self.data = data
        self.rchild = None
        self.lchild = None

    def add(self, data):
        node = Node(data=data)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

二叉树的遍历：

其中二叉树的遍历两种方式，广度遍历和深度遍历的方式，深度遍历又分为先序，中序，后序遍历。

1. 广度遍历的思想和构建二叉树的思想类似，这里就不做详细的介绍。直接附上代码

    def breath_travese(self):
        """广度遍历"""
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.data, 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)

2. 深度遍历的先序，中序，后序遍历，他们主要是对于访问的节点的起始不同，这样我们就能够将数据输出位置进行不同位置的放置，就能够实现三种功能。

  """
    深度遍历方式
    """

    def preorder_tra(self, node):
        """先序遍历"""
        if node is None:
            return
        print(node.data, end=" ")
        self.preorder_tra(node.lchild)
        self.preorder_tra(node.rchild)

    def inorder_tra(self, node):
        """中序遍历"""
        if node is None:
            return
        self.inorder_tra(node.lchild)
        print(node.data, end=" ")
        self.inorder_tra(node.rchild)

    def postorder_tra(self, node):
        if node is None:
            return
        self.inorder_tra(node.lchild)
        self.inorder_tra(node.rchild)
        print(node.data, end=" ")

这上面的程序都是使用了递归调用，这里面也可以用循环的方式调用，但是个人认为，没有递归的方式简单，易懂，所以选择递归。最后附上完整代码块

"""
树形结构的遍历
先序遍历，中序遍历，后序遍历，然后统计树高和叶子节点
"""


class Node:
    """
    首先构建树形的节点框架
    存储数据：data，左右孩子节点：right,left
    """

    def __init__(self, data):
        self.data = data
        self.rchild = None
        self.lchild = None


# 数据的遍历访问
class Tree:
    def __init__(self):
        self.root = None

    # 树形结构构建
    def add(self, data):
        node = Node(data=data)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

    def breath_travese(self):
        """广度遍历"""
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.data, 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 preorder_tra(self, node):
        """先序遍历"""
        if node is None:
            return
        print(node.data, end=" ")
        self.preorder_tra(node.lchild)
        self.preorder_tra(node.rchild)

    def inorder_tra(self, node):
        """中序遍历"""
        if node is None:
            return
        self.inorder_tra(node.lchild)
        print(node.data, end=" ")
        self.inorder_tra(node.rchild)

    def postorder_tra(self, node):
        if node is None:
            return
        self.inorder_tra(node.lchild)
        self.inorder_tra(node.rchild)
        print(node.data, end=" ")


if __name__ == "__main__":
    tree = Tree()
    while True:
        data = input()
        if data is "#":
            break
        else:
            tree.add(data=data)
    print("广度优先遍历", end=":")
    tree.breath_travese()
    print()
    print("深度优先遍历-先序遍历", end=":")
    tree.preorder_tra(tree.root)
    print()
    print("深度优先遍历-中序遍历", end=":")
    tree.inorder_tra(tree.root)
    print()
    print("深度优先遍历-后序遍历", end=":")
    tree.postorder_tra(tree.root)

这文是参考网上的教学视频，然后根据自己理解写出来的，希望大家只是借鉴。