树、二叉树实现（深度优先和广度优先、递归非与递归实现）（python）

树状图是一种数据结构，它是由n（n>=1）个有限结点组成一个具有层次关系的集合。它具有以下的特点：

• 每个结点有零个或多个子结点；
• 没有父结点的结点称为根结点；
• 每一个非根结点有且只有一个父结点；
• 除了根结点外，每个子结点可以分为多个不相交的子树；

树相关名词：

• 节点的度：一个节点含有的子树的个数称为该节点的度；
• 树的度：一棵树中，最大的节点的度称为树的度；
• 叶节点或终端节点：度为零的节点；
• 父亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
• 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
• 兄弟节点：具有相同父节点的节点互称为兄弟节点；
• 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
• 树的高度或深度：树中节点的最大层次；
• 堂兄弟节点：父节点在同一层的节点互为堂兄弟；
• 节点的祖先：从根到该节点所经分支上的所有节点；
• 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
• 森林：由m（m>=0）棵互不相交的树的集合称为森林；

树的种类：

• 无序树：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树；
• 有序树：树中任意节点的子节点之间有顺序关系，这种树称为有序树；
• 二叉树：每个节点最多含有两个子树的树称为二叉树；
• 完全二叉树：对于一棵二叉树，假设其深度为d(d>1)。除了第d层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列。
• 满二叉树：所有叶节点都在最底层的完全二叉树;
• 平衡二叉树（AVL树）：当且仅当任何节点的两棵子树的高度差不大于1的二叉树；
• 霍夫曼树（用于信息编码）：带权路径最短的二叉树称为哈夫曼树或最优二叉树；

树的存储：

• 链式存储：（链表）缺点：指针域的个数不定，由于对节点的个数无法掌握，常见树的存储表示都转换成二叉树进行处理，子节点个数最多为2
• 顺序存储：将数据结构存储在固定的数组中，然在遍历速度上有一定的优势，但因所占空间比较大

二叉树：二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）

二叉树特性：

• 在二叉树的第i层上至多有2^(i-1)个结点（i>0）
• 深度为k的二叉树至多有2^k - 1个结点（k>0）
• 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
• 具有n个结点的完全二叉树的深度必为 log2(n+1)
• 对完全二叉树，若从上至下、从左至右编号，则编号为i 的结点，其左孩子编号必为2i，其右孩子编号必为2i＋1；其双亲的编号必为i/2（i＝1 时为根,除外）

二叉树的节点表示以及树的创建

节点类：

属性：data、lchild、rchild

class Node(object):
    def __init__(self,data,lchild,rchild):
        self.data = data
        self.lchild = lchild
        self.rchild = rchild

树类：

类方法：add（添加节点）

class Tree(object):
    def __init__(self,root=None):
        self.root = root

二叉树的遍历：  深度优先遍历 和 广度优先遍历

区别：

二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

深度优先搜素算法：不全部保留结点，占用空间少；有回溯操作(即有入栈、出栈操作)，运行速度慢。

广度优先搜索算法：保留全部结点，占用空间大； 无回溯操作(即无入栈、出栈操作)，运行速度快。

 

深度优先遍历：前序遍历（preorder），中序遍历（inorder）和后序遍历（postorder）

• 前序遍历：根节点->（递归）左子树->（递归）右子树
• 中序遍历：左子树->根节点->（递归）右子树
• 后序遍历：左子树（递归）->右子树（递归）->根节点

广度优先遍历：从树的root开始，从上到下从从左到右遍历整个树的节点（类似添加的过程）

#定义树类
class Tree(object):
    def __init__(self,root=None):
        self.root = root
    #添加节点
    def add(self,data):
        Tnode = Node(data)
        if self.root == None:
            self.root = Tnode
        else:
            child = []
            child.append(self.root)
            while child:
                curNode = child.pop(0)  #删除的同时会返回删除值
                if curNode.lchild==None:
                    curNode.lchild = Tnode
                    return
                elif curNode.rchild ==None:
                    curNode.rchild = Tnode
                    return
                else:
                    #保证从上到下 从左到右  判断当前层的同时按序保存下层节点
                    child.append(curNode.lchild)
                    child.append(curNode.rchild)

    #深度优先遍历 根节点->（递归）左子树->（递归）右子树
    def preorder(self, root):
        """递归实现先序遍历"""
        if root == None:
            return
        print(root.data,end=' ')
        self.preorder(root.lchild)
        self.preorder(root.rchild)

    #非递归
    #思想：借助一个栈结构先将根结点压入栈，然后循环每次取出栈顶元素，直到栈为空。如果当前结点有右
         #孩子就先将右孩子压入栈中，如果当前结点有左孩子就将左孩子压入栈中，这里注意顺序，因为栈
         #的结构是先进后出的，为了保证先遍历到左孩子就应该后压左孩子~
    def non_preorder(self, root):
        """非递归实现先序遍历（根左右）"""
        if not root:
            return
        stack = [root]  #进栈
        while stack:
            node = stack.pop()
            print(node.data, end=' ')
            if node.rchild:   #右孩子 存在压入栈 左在右前  左先栈即右在前进栈
                stack.append(node.rchild)
            if node.lchild:   #左孩子 存在压入栈
                stack.append(node.lchild)

    #深度优先遍历 中序遍历：左子树->根节点->（递归）右子树
    def inorder(self, root):
        """递归实现中序遍历"""
        if root == None:
            return
        self.inorder(root.lchild)
        print(root.data,end=' ')
        self.inorder(root.rchild)

    #非递归
    #思想 借助栈结构，将当前结点的左孩子依次入栈直到没有左孩子了就弹出栈顶元素并打印，如果弹出的 
         #结点有右孩子就将右孩子的左边界依次入栈，循环…
    def non_inorder(self, root):
        """递归实现中序遍历(左根右)"""
        stack = []
        node= root
        while node or len(stack)>0:
            while node:  # 把当前节点的所有左侧子结点压入栈
                stack.append(node)
                node = node.lchild
            if len(stack)>0:
                node = stack.pop()
                print(node.data,end=' ')
                node = node.rchild   # 右空 不会执行while  直接输出根，根存在右，则右进栈

    # 深度优先遍历 后序遍历：左子树（递归）->右子树（递归）->根节点
    def postorder(self, root):
        if root == None:
            return
        self.postorder(root.lchild)
        self.postorder(root.rchild)
        print(root.data,end=' ')

    #非递归
    #思想(1)不断往左子树深入并不断入栈直到左叶子的空左孩子
      #(2)弹出栈顶，如果右孩子为null或者last是右孩子，则打印当前值；如果不是，则将指针指向右孩子
      #(3) 循环1,2步骤直至栈为空且指针也为空
     def non_postorder(self, root):
         stack = []
         node= root
         preNode = None
         while node or len(stack)>0:
             while node:  # 把当前节点的所有左侧子结点压入栈
                 stack.append(node)
                 node = node.lchild
             if len(stack)>0:
                 temp = stack.pop()
                 if temp.rchild==None or temp.rchild==preNode:   # 左孩为空则一定执行输出，且记录  或者访问过右孩  则执行
                     print(temp.data, end=' ')
                     preNode = temp #记录刚被访问过的节点
                 else: #当节点右没有访问过，则当前节点先入栈，先处理右孩
                     stack.append(temp)
                     node = temp.rchild

    #广度优先遍历(层次遍历)
    def layer(self):
        if self.root == None:
            return
        queue = []
        queue.append(self.root)
        while queue:
            node = queue.pop(0)
            print(node.data,end=' ')
            if node.lchild != None:
                queue.append(node.lchild)
            if node.rchild != None:
                queue.append(node.rchild)

测试及结果：

if __name__ == '__main__':
    tree = Tree()
    for i in range(10):
        tree.add(i)
    tree.layer()
    print()
    tree.preorder(tree.root)
    print()
    tree.inorder(tree.root)
    print()
    tree.postorder(tree.root)

###结果####
广度优先：
0 1 2 3 4 5 6 7 8 9 
深度，递归前序：
0 1 3 7 8 4 9 2 5 6 
深度，非递归前序：
0 1 3 7 8 4 9 2 5 6 
深度，递归中序：
7 3 8 1 9 4 0 5 2 6 
深度，非递归中序：
7 3 8 1 9 4 0 5 2 6 
深度，递归后序：
7 8 3 9 4 1 5 6 2 0 
深度，非递归后序：
7 8 3 9 4 1 5 6 2 0