Python实现二叉树

二叉树是由n（n≥0）个结点组成的有限集合、每个结点最多有两个子树的有序树。它或者是空集，或者是由一个根和称为左、右子树的两个不相交的二叉树组成。

特点：

• 二叉树是有序树，即使只有一个子树，也必须区分左、右子树； 
• 二叉树的每个结点的度不能大于2，只能取0、1、2三者之一;
• 叉树中所有结点的形态有5种：空结点、无左右子树的结点、只有左子树的结点、只有右子树的结点和具有左右子树的结点。

#定义单个节点
class Node:
    def __init__(self,data,lchild=None,rchild=None):
        self.data = data
        self.lchild = lchild
        self.rchild = rchild

#定义一个二叉树
class BinTree(object):
    def __init__(self):
        self.root = None#初始化的时候为none

    def add(self, data):
        node = Node(data)
        if self.root is None:#如果根节点为空的话则把这个节点赋给root节点
            self.root = node
        else:
            q = [self.root] #root 节点为非空的时候则把节点放入列表中
            while True:#
                pop_node = q.pop(0)
                if pop_node.lchild is None:
                    pop_node.lchild = node
                    return
                elif pop_node.rchild is None:
                    pop_node.rchild = node
                    return
                else:
                    q.append(pop_node.lchild)
                    q.append(pop_node.rchild)
#----------先出根节点，然后根节点左右节点依次类推
    def traverse(self):  # 层次遍历
        if self.root is None:#如果根节点为空，则返回节点为空
            return None
        q = [self.root]#q列表中放入root对象
        res = [self.root.data]#res中放入数据
        while q != []:#当q列表不为空的时候
            pop_node = q.pop(0)
            if pop_node.lchild is not None:
                q.append(pop_node.lchild)
                res.append(pop_node.lchild.data)

            if pop_node.rchild is not None:
                q.append(pop_node.rchild)
                res.append(pop_node.rchild.data)
        return res

    #------先序遍历-------
    #先根节点，遍历所有树的左子树，在遍历所有数的右子树
    def preorder(self,root):  # 先序遍历
        if root is None:
            return []
        result = [root.data]
        #通过递归调用。。。。。
        left_item = self.preorder(root.lchild)
        right_item = self.preorder(root.rchild)
        #合并列表过程
        return result + left_item + right_item
    #先访问左子树，根节点 ，右子树
    def inorder(self,root):  # 中序序遍历
        if root is None:
            return []
        result = [root.data]
        #-------递归调用---------
        left_item = self.inorder(root.lchild)
        right_item = self.inorder(root.rchild)
        return left_item + result + right_item
    #先左子树，后右子树，根节点
    def postorder(self,root):  # 后序遍历
        if root is None:
            return []
        result = [root.data]
        #-------递归调用---------
        left_item = self.postorder(root.lchild)
        right_item = self.postorder(root.rchild)
        return left_item + right_item + result
    #二叉树的深度
    def Depth(self,root):
        if root is None:
            return 0
        else:
            m=self.Depth(root.lchild)
            n=self.Depth(root.rchild)
        if m>n:
            return m+1
        else:
            return n+1

    #计算二叉树的节点
    def CountNode(self,root):
        if root is None:
            return 0
        else:
            return self.CountNode(root.lchild)+self.CountNode(root.rchild)+1

t = BinTree()
for i in range(10):
    t.add(i)
print('层序遍历:',t.traverse())
print('先序遍历:',t.preorder(t.root))
print('中序遍历:',t.inorder(t.root))
print('后序遍历:',t.postorder(t.root))
print('树深',t.Depth(t.root))
print('节点数',t.CountNode(t.root))

以上是二叉树的一些操作的代码。