树的概念及其术语

概念
树是一种抽象数据类型或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

术语

• 节点的度 一个节点含有的子树的个数成为该节点的度
• 树的度 一棵树中，最大的节点的度成为数的度
• 叶节点或终父节点 度为零的节点
• 父亲节点或子节点 若一个节点含有子节点，则这个节点成为其子节点的父亲点
• 孩子节点或子节点 一个节点含有的子树的根节点成为该节点的子节点
• 兄弟节点 具有相同父节点的节点互称为兄弟节点
• 结点的层次 从根开始定义起，根为第1层，根的子节点为第2曾，以此类推。
• 树的高度或深度 树中节点的最大层次
• 堂兄弟节点 父节点在同一层的节点互为堂兄弟节点
• 子节点的祖先 从根到该节点所经分支上的所有节点
• 子孙 以某节点为根的子树中任一节点都称为该节点的子孙。

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

二叉树代码实现

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]
        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 preoder(self,node):
        """前序遍历（根左右）"""
        if node is None:
            return
        print(node.elem,end=" ")
        self.preoder(node.lchild)
        self.preoder(node.rchild)

    def inoder(self, node):
        """中序遍历（左根右）"""
        if node is None:
            return
        self.inoder(node.lchild)
        print(node.elem, end=" ")
        self.inoder(node.rchild)

    def postoder(self, node):
        """中序遍历（左右根）"""
        if node is None:
            return
        self.postoder(node.lchild)
        self.postoder(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)
    tree.breadth_travel()
    print(" ")
    tree.preoder(tree.root)
    print(" ")
    tree.inoder(tree.root)
    print(" ")
    tree.postoder(tree.root)

首先建立了一颗树，然后往树里添加元素1，2，3，4，5，6，7，8，9，首先广度遍历一次这棵树，然后先序遍历，再中序遍历，最后后序遍历。

输出结果

0 1 2 3 4 5 6 7 8 9  
0 1 3 7 8 4 9 2 5 6  
7 3 8 1 9 4 0 5 2 6  
7 8 3 9 4 1 5 6 2 0 

最后说一下怎么由遍历确定一颗二叉树。

首先知道光有一种顺序是不能让我们确定的，因为一种顺序不能确定他的左右。所以我们必须要两个顺序，而且必须含有中序，因为中序可以确定左子树和右子树，所以我们必须需要两个顺序来确定一棵树。