二叉树的实现与遍历（Python）

1.二叉树是指每个节点最多有两个子树的树结构。

2.二叉树的数学性质：a.第I层上至多有2^(i-1)个节点

                                    b.对于一个深度为k的二叉树，最多有（2^k - 1）个节点

                                    c.任意一个二叉树，叶节点个数为N0，度数为2的节点个数为N2，N0=N2+1

                                    d.有n个节点的完全二叉树，h=log2 (n) + 1  

3.二叉树又分为：完全二叉树    （二叉树有h层，除h层都达到最大度）

                            满二叉树       （完全二叉树的基础上h层也达到最大的度）

                            平衡二叉树   （对于任意一个父节点的子树间深度差不超过1）

                            排序二叉树   （对于根节点，若左子树不为空则左子树的数都小于根节点，若右子树不为空则右子树的数都大于                                                        根节点，且左右子树均为平衡二叉树）

4.树的遍历分为广度优先遍历和深度优先遍历：

                           广度优先遍历又称为层次遍历，即按照每一层从左至右，从上到下的顺序遍历；

                           深度优先遍历分为：先序遍历（根 左 右）

                                                           中序遍历（左 根 右）

                                                           后序遍历（左 右 根）

   代码实现：

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 == 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 == None:
            return
        print(node.elem, end=" ")
        self.preorder(node.lchild)
        self.preorder(node.rchild)
    
    def inorder(self, node):
        """中序遍历"""
        if node == None:
            return
        self.inorder(node.lchild)
        print(node.elem, end=" ")
        self.inorder(node.rchild)
        
    def posorder(self, node):
        """后序遍历"""
        if node == None:
            return
        self.posorder(node.lchild)
        self.posorder(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.preorder(tree.root)
    print(" ")
    tree.inorder(tree.root)
    print(" ")
    tree.posorder(tree.root)