golang二叉树的递归和非递归方式的前中后序遍历

方法一：递归
思路与算法

首先我们需要了解什么是二叉树的中序遍历：按照访问左子树——根节点——右子树的方式遍历这棵树() (前序和后序遍历方式一样，就是打印root节点时，前序是：根节点-左子树-右子树；后序是：左子树-右子树-根节点) ，而在访问左子树或者右子树的时候我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质，我们可以直接用递归函数来模拟这一过程。

定义 inorder(root) 表示当前遍历到 root 节点的答案，那么按照定义，我们只要递归调用 inorder(root.left) 来遍历 root 节点的左子树，然后将 root 节点的值加入答案，再递归调用inorder(root.right) 来遍历root 节点的右子树即可，递归终止的条件为碰到空节点。

package main

import "fmt"


func main()  {
	var root TreeNode
	root = TreeNode{value: 1}
	root.left = &TreeNode{2,nil,nil}
	root.right = &TreeNode{3,nil,nil}
	root.left.left = &TreeNode{4,nil,nil}
	root.left.right = &TreeNode{5,nil,nil}
	root.right.left = &TreeNode{6,nil,nil}
	root.right.right = CreateNode(7)
	root.Traverse()
}

type TreeNode struct {
	value 		int
	left, right *TreeNode
}
func (node *TreeNode) Print(){
	fmt.Println(node.value)
}
func (node *TreeNode) inorderTraversal(f func(node *TreeNode)){
	if node == nil{
		return
	}
	f(node)
	node.left.inorderTraversal(f)
	node.right.inorderTraversal(f)
}

func (node *TreeNode) Traverse() {
	node.inorderTraversal(func(n *TreeNode){
		n.Print()
	})
}

复杂度分析

时间复杂度：O(n)，其中 nn 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。

方法二：栈
思路与算法

方法一的递归函数我们也可以用迭代的方式实现，两种方式是等价的，区别在于递归的时候隐式地维护了一个栈，而我们在迭代的时候需要显式地将这个栈模拟出来，其他都相同，具体实现可以看下面的代码。

package main

import "fmt"

type TreeNode struct{
	value int
	left, right *TreeNode
}

func inorder(root *TreeNode) (res []int) {
	var stack []*TreeNode
	for root != nil || len(stack) > 0 {
		for root != nil{
			stack = append(stack, root)
			root = root.left
		}
		root = stack[len(stack) - 1]
		stack = stack[:len(stack)-1]
		res = append(res,root.value)
		root = root.right
	}
	return res
}
func main()  {
	var node TreeNode
	node = TreeNode{1,nil,nil}
	node.left = &TreeNode{2,nil,nil}
	node.right = &TreeNode{3,nil,nil}
	fmt.Println(inorder(&node))
}

非递归的前序遍历

func preOrder(root *TreeNode) (res []int){
	var stack []*TreeNode
	for root != nil || len(stack) > 0{
		for root != nil{
			res = append(res, root.value)
			stack = append(stack, root)
			root = root.left
		}
		root = stack[len(stack)-1].right
		stack = stack[:len(stack)-1]
	}
	return
}

非递归的后序遍历

func postOrder(root *TreeNode) (res []int){
	var stack []*TreeNode
	var prev  *TreeNode
	for root != nil || len(stack) > 0{
		for root != nil{
			stack = append(stack, root)
			root = root.left
		}
		root = stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		if root.right == nil || root.right == prev{
			res = append(res, root.value)
			prev = root
			root = nil
		} else{
			stack = append(stack, root)
			root = root.right
		}
	}
	return res
}

不懂匿名函数的可以看文档，这边就不阐述了，后面有机会再一点点分享

http://www.topgoer.com/%E5%87%BD%E6%95%B0/%E5%87%BD%E6%95%B0%E5%AE%9A%E4%B9%89.html