二叉树的前中后序遍历

前序递归：

func preorderTraversal(root *TreeNode) []int {
    res := []int{}
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode) {
        if node == nil {
            return
        }
        res = append(res, node.Val)
        traversal(node.Left)
        traversal(node.Right)
    }
    traversal(root)
    return res
}

前序迭代：

func preorderTraversal(root *TreeNode) []int {
    //前序遍历其实上就是相当于需要自己实现一个栈（不用递归的方式）
    ans := []int{}
    if root == nil {
        return ans
    }
    st := list.New()
    st.PushBack(root)
    /相当于维护了一个栈，压入的时候，先压入根节点，再压入右节点，在左节点（这样弹出的时候就是先弹左，再弹右了）
    for st.Len() > 0 {
        node := st.Remove(st.Back()).(*TreeNode)
        ans = append(ans, node.Val)
        if node.Right != nil {
            st.PushBack(node.Right)
        }
        if node.Left != nil {
            st.PushBack(node.Left)
        }
    }
    return ans
}

中序递归：

func inorderTraversal(root *TreeNode) []int {
    res := []int{}
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode) {
        if node == nil {
            return 
        }
        traversal(node.Left)
        res = append(res, node.Val)
        traversal(node.Right)
    }
    traversal(root)
    return res
}

中序迭代：

func inorderTraversal(root *TreeNode) []int {
    //中序遍历是左根右，所以要先找到最左的那个节点
    ans := []int{}
    if root == nil {
        return ans
    }
    st := list.New()
    cur := root //定义一个指针

    for cur != nil || st.Len() > 0 {
        if cur != nil {
            st.PushBack(cur)
            cur = cur.Left //先把左节点压入栈，直到最左边的
        } else {
        //弹出cur,放入结果数组中；有右节点的在将其压入栈，没有的话cur为nil，则会再从栈中弹出一个数据赋值给cur
            cur = st.Remove(st.Back()).(*TreeNode)
            ans = append(ans, cur.Val)
            cur = cur.Right
        }
    }
    return ans
}

后序递归：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    res := []int{}
    var traversal func(node *TreeNode)
    traversal = func(node *TreeNode) {
        if node == nil {
            return
        }
        traversal(node.Left)
        traversal(node.Right)
        res = append(res, node.Val)
    }
    traversal(root)
    return res
}

后序迭代：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    ans := []int{}
    if root == nil {
        return ans
    }
    st := list.New()
    st.PushBack(root)

    for st.Len() > 0 {
        node := st.Remove(st.Back()).(*TreeNode)
        ans = append(ans, node.Val)
        if node.Left != nil {
            st.PushBack(node.Left)
        }

        if node.Right != nil {
            st.PushBack(node.Right)
        }
    }
    reverse(ans)
    return ans
}

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