二叉树中的七种遍历

1、题目描述：二叉树的构建、深度遍历（6种）、层次遍历

# -*- coding: utf-8 -*-
"""
Created on Tue Jun 19 10:31:40 2018

@author: Administrator
"""
class  Node():
    def __init__(self,elem=-1,lchild=None,rchild=None):
        self._elem=elem
        self._lchild=lchild
        self._rchild=rchild
        
class BinaryTree():
    def __init__(self):
        self._root=Node()
        self._myQueue=[]
        
    def add(self,elem):#为树添加节点
        node=Node(elem)
        if self._root._elem==-1:#如果树是空的，则对根节点赋值
            self._root=node
            self._myQueue.append(self._root)
        else:
            treeNode=self._myQueue[0]
            if treeNode._lchild==None:
                treeNode._lchild=node
                self._myQueue.append(treeNode._lchild)
            else:
                treeNode._rchild=node
                self._myQueue.append(treeNode._rchild)
                self._myQueue.pop(0)#用于叶节点的子节点增加（层次）
        
    def front_digui(self,root):#先序递归
        if root==None:
            return 
        print (root._elem)
        self.front_digui(root._lchild)
        self.front_digui(root._rchild)
    
    def middle_digui(self,root):#中序递归
        if root==None:
            return 
        self.middle_digui(root._lchild)
        print(root._elem)
        self.middle_digui(root._rchild)
        
    def later_digui(self,root):#后序递归
        if root==None:
            return 
        self.later_digui(root._lchild)
        self.later_digui(root._rchild)
        print(root._elem)
        
        
    def front_stack(self,root):#先序非递归（堆栈）
        #第一次经过，压栈，访问，取其左
        #第二次经过，出栈，取其右
        if root==None:
            return
        myStack=[]
        node=root
        while node or myStack:
            while node:               
                myStack.append(node)
                print (node._elem)
                node=node._lchild
            node=myStack.pop()
            node=node._rchild
    
        
    def middle_stack(self,root):#中序非递归（堆栈）
        #第一次经过，压栈，取其左
        #第二次经过，出栈，访问，取其右
        if root==None:
            return
        myStack=[]
        node=root
        while node or myStack:
            while node:
                myStack.append(node)
                node=node._lchild
            node=myStack.pop()
            print (node._elem)
            node=node._rchild
       
    def later_stack(self,root):#后序非递归（两个堆栈）
        if root==None:
            return 
        myStack1=[]
        myStack2=[]
        node=root
        myStack1.append(node)
        while myStack1:#这个while循环的功能是找出后序遍历的逆序，存在myStack2里面
            node=myStack1.pop()#这个列表相当于栈
            if node._lchild:
                myStack1.append(node._lchild)
            if node._rchild:
                myStack1.append(node._rchild)
            myStack2.append(node)
        while myStack2:#将myStack2中的元素出栈，即为后序遍历次序
            print (myStack2.pop()._elem)
        
    def level_queue(self,root):#层次遍历
        result=[]
        if root==None:
            return result
        myQueue=[]
        node=root
        myQueue.append(node)
        while myQueue:
            node=myQueue.pop(0)#这个列表相当于队列
            #print (node._elem)
            result.append(node._elem)
            if node._lchild:
                myQueue.append(node._lchild)
            if node._rchild:
                myQueue.append(node._rchild)
        return result
                
tree=BinaryTree()   
for i in range(5):
    tree.add(i)             
#tree.front_digui(tree._root)
#tree.middle_digui(tree._root)
#tree.later_digui(tree._root)

#tree.front_stack(tree._root)
#tree.middle_stack(tree._root)
#tree.later_stack(tree._root)

a=tree.level_queue(tree._root)
print (a)

3、总结：深度优先一般用递归，广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。