python递归及非递归实现二叉树的三种遍历

#defination of a TreeNode
class Node:
    def __init__(self,value=None,left=None,right=None):
        self.val=value
        self.left=left
        self.right=right
class Solution:
    def forwardRead(self,root):
        if root==None:
            return
        print(root.val)
        self.forwardRead(root.left)
        self.forwardRead(root.right)
    def forwardReadStack(self,root):
        if not root:
            return
        preStack=[]
        node=root
        while preStack or node:
            while node:
                print(node.val)
                preStack.append(node)
                node=node.left
            node=preStack.pop()
            node=node.right
    def middleRead(self,root):
        if root==None:
            return
        self.middleRead(root.left)
        print(root.val)
        self.middleRead(root.right)
    def middleReadStack(self,root):
        if root==None:
            return
        node=root
        middleStack=[]
        while middleStack or node:
            while node:
                middleStack.append(node)
                node=node.left
            node=middleStack.pop()
            print(node.val)
            node=node.right
    def afterRead(self,root):
        if root==None:
            return
        # print("root.val:",root.val)
        self.afterRead(root.left)
        self.afterRead(root.right)
        print(root.val)
    def afterReadStack(self,root):
        if root==None:
            return
        afterStack=[]
        tempStack=[]
        node=root
        while afterStack or node:
            while node:
                afterStack.append(node)
                tempStack.append(node)
                node=node.right
            node=afterStack.pop()
            node=node.left
        while tempStack:
            print(tempStack.pop().val)
    #如果是树的话，每一层推进的时候，不会有重复的
    #但是如果是图或者抽象的状态集，很可能会有重复的
	def BFS(self, root):
   		if root == None:
        	return
    	queue=[]
    	start=root
    	queue.append(start)
    	while queue:
        	node=queue.pop(0)
        	print(node.val)
        	if node.left:
            	queue.append(node.left)
        	if node.right:
            	queue.append(node.right)


if __name__=='__main__':
    root=Node('D',Node('B',Node('A'),Node('C')),Node('E',right=Node('G',Node('F'))))
    su=Solution()
    print("递归实现")
    su.afterRead(root)
    print("非递归实现")
    su.afterReadStack(root)
    print("层次遍历")
    su.BFS(root)