二叉树前序、中序、后序遍历，递归&迭代

94. 二叉树的中序遍历

// 迭代实现
func inorderTraversal1(root *TreeNode) (res []int) {
	stk := make([]*TreeNode, 0)
	for len(stk) > 0 || root != nil {
		for root != nil {
			stk = append(stk, root)
			root = root.Left
		}
		root = stk[len(stk)-1]
		stk = stk[:len(stk)-1]
		res = append(res, root.Val)
		root = root.Right
	}
	return
}
// 递归实现
var ans []int
func inorderTraversal(root *TreeNode) []int {
	ans = make([]int, 0)
	help(root)
	return ans
}

func help(root *TreeNode) {
	if root != nil {
		help(root.Left)
		ans = append(ans, root.Val)
		help(root.Right)
	}
}

144. 二叉树的前序遍历

// 迭代实现
var ans []int
func preorderTraversal(root *TreeNode) []int {
    ans = make([]int, 0)
    stack := make([]*TreeNode, 0)
    if root == nil {
        return ans
    }
    stack = append(stack, root)
    for len(stack) > 0 {
        node := stack[len(stack) -1]
        stack = stack[:len(stack)-1]
        ans = append(ans, node.Val)
        // 这里先压node.Right 再压node.Left
        if node.Right != nil {
            stack = append(stack, node.Right)
        }
        if node.Left != nil {
            stack = append(stack, node.Left)
        }
    }
    return ans
}

45. 二叉树的后序遍历

// 目标: [左 右 根]
// 思路：[根 右 左]遍历，然后reverse
func postorderTraversal(root *TreeNode)(ans []int) {
    stk := make([]*TreeNode, 0)
    if root == nil {
        return
    }
    stk = append(stk, root)
    for len(stk) > 0 {
        node := stk[len(stk) - 1]
        stk = stk[:len(stk) - 1]
        ans = append(ans, node.Val)
        // 注意左右节点的压栈顺序和判空
        if node.Left != nil {
            stk = append(stk, node.Left)
        }
        if node.Right != nil {
            stk = append(stk, node.Right)
        }
    }
    reverseSlice(ans)
    return
}

func reverseSlice(s []int) {
    left, right := 0, len(s) - 1
    for left < right {
        s[left], s[right] = s[right], s[left]
        left ++
        right --
    }
}