数据结构——树的概念以遍历方法实现

二叉树：二叉树是每个节点最多有两个子树的树结构，通常被称为左子树和右子树。

二叉树的特性：
1.在二叉树的第i层上最多有2^(i-1)个节点(i>0)。
2.深度为k的二叉树最多有2^k-1个节点(k>0)。
3.对于任意一颗二叉树，如果其叶节点数为N0，而度数为2的节点总数为N2，则N0=N2+1。
4.具有n个节点的完全二叉树的深度必为log2(n+1)。
5.对于完全二叉树，若从上至下，从左至右编号，则编号为i的节点，其左孩子编号必为2i，右孩子编号必为2i+1，其双亲编号为i/2(i=1时为根，无双亲节点，除外)。

遍历：
广度遍历：层次遍历
先序遍历：根，左，右
中序遍历：左，根，右
后序遍历：左，右，根

代码实现：

# tree

# 构建节点类
class Node(object):
    '''二叉树的节点'''
    def __init__(self, item):
        self.elem = item
        self.lchild = None
        self.rchild = None

# 构造二叉树类
class Tree(object):
    '''二叉树'''
    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] # 首先将根节点放入队列
        # 如果根节点为空，则将新节点设置为根节点
        if self.root is None:
            self.root = node
            return

        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 breadth_travel(self):
        '''广度遍历'''
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.elem, 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(self, node):
        '''先序遍历'''
        # 如果根节点为空，直接返回
        if node is None:
            return
        else:
            # 先打印根，再处理左子树（把左当作一个新节点来递归处理），再处理右子树（把右当作一个新节点来递归处理）
            print(node.elem, end=' ')
            # 递归方法
            self.preorder(node.lchild)
            self.preorder(node.rchild)

    # 中序遍历
    def inorder(self, node):
        '''中序遍历'''
        # 如果根节点为空，直接返回
        if node is None:
            return
        else:
            # 先处理左子树（把左当作一个新节点来递归处理），再打印根，再处理右子树（把右当作一个新节点来递归处理）
            self.inorder(node.lchild)
            print(node.elem, end=' ')
            self.inorder(node.rchild)

    # 后序遍历
    def postorder(self, node):
        '''中序遍历'''
        # 如果根节点为空，直接返回
        if node is None:
            return
        else:
            # 先处理左子树（把左当作一个新节点来递归处理），再处理右子树（把右当作一个新节点来递归处理），再打印根）
            self.postorder(node.lchild)
            self.postorder(node.rchild)
            print(node.elem, end=' ')


if __name__ == '__main__':
    tree = Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)

    print('广度遍历：', end='')
    tree.breadth_travel()
    print('\n')

    print('先度遍历：', end='')
    tree.preorder(tree.root)
    print('\n')

    print('中度遍历：', end='')
    tree.inorder(tree.root)
    print('\n')

    print('后度遍历：', end='')
    tree.postorder(tree.root)

程序运行结果如图：