二叉树的前序遍历，中序遍历以及后序遍历的python写法

定义一颗二叉树

二叉树的属性包括：当前节点的值，左子树以及右子树

利用python构建二叉树

class Treenode(object):
	def __init__(self,value,left=None,right=None)
		self.val=value
		self.left=left
		self.right=right
a=Treenode(1,Treenode(2,Treenode(4)),Treenode(3,Treenode(5)))

如图所示：

二叉树的前序遍历

前序遍历:先访问根节点，然后遍历左子树，最后遍历右子树。在遍历左子树的时候，仍然按照先访问根节点，再访问左子树，然后访问右子树。在访问右子树的时候，也按照先访问根节点，然后左子树，最后右子树。

前序遍历的递归算法

class Solution_f(root):
	if root is not None:
		print(root.val)
		Solution_f(root.left)
		Solution_f(root.right)
print(Solution_f(a))		

"""
结果如下
"""
1
2
4
3
5

前序遍历的非递归算法

思路：用一个列表来存储遍历的结果，用栈来存储要遍历的节点。栈是后进先出的顺序。

class Solution(object):
	def preorderTraversal(self,root):
		ret=[]#用来存放遍历的结果
		stack=[]#用来存放要遍历的节点
		while root or stack:#当前节点为空为终止条件,stack中的节点要出栈
			while root:
				ret.append(root.val)#添加当前节点的值
				stack.append(root)#遍历左子树并且入栈
				root=root.left
			if stack:
				t=stack.pop()#最后的节点先出栈
				root=t.right#遍历右子树
		return ret
				
result=Solution().preorderTraversal(a)	
print(result)			

"""
结果如下
"""
[1,2,4,3,5]

二叉树的中序遍历

中序遍历: 先遍历左子树，然后访问根节点，最后访问右子树。在访问左右子树时，仍然先访问左子树，再访问根节点，最后访问右子树。

中序遍历的递归算法

class Solution_m(root):
	if root is not None:
		Solution_m(root.left)
		print(root.val)
		Solution_m(root.right)
Solution_m(a)

"""
结果如下
"""
4
2
1
5
3

中序遍历的非递归算法

class Solution(object):
	def miorderTraversal(self,root):
		ret=[]#存放遍历的结果
		stack=[]#存放遍历的节点
		while root or stack:#满足条件就循环
			while root:
				stack.append(root)
				root=root.left#遍历左子树
			if stack:
				t=stack.pop()#后进的节点先出
				ret.append(t.val)
				root=t.right
		return ret
result=Solution().miorderTraversal(a)
print(result)											

"""
结果如下所示
"""
[4,2,1,5,3]

二叉树的后序遍历

后序遍历：先遍历左子树，然后访问右子树，最后访问根节点。在遍历左右子树的时候，仍然按照先先访问左子树，然后访问右子树，最后访问根节点的顺序进行。

后序遍历的递归算法

class Solution_b(root):
		if root is not None:
			Solution_b(root.left)
			Solution_b(root.right)
			print(root.val)
Solution_b(a)

"""
如下所示

"""
4
2
5
3
1

后序遍历非递归算法

思路：用两个栈，一个栈用来存储结果，一个则是存储当前节点

class Solution(object):
	def laorderTraversal(self,root);
	    ret=[]
	    stack=[]
	    ret.append(root)
	    while ret:
	    	node=ret.pop()
	    	stack.append(node)
	    	if node.left:
	    		ret.append(node.left)
    		if node.right:
    			ret.append(node.right)
 		while stack:
 			print(stack.pop().value)
result=Solution().laorderTraversal(a)

"""输出结果"""
4
2
5
3
1

稍微梳理了一下，欢迎大家指正，共同进步。