中序

左右根

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

前序

根左右

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

后序

左右根

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

层序

bfs

func levelOrder(root *TreeNode) [][]int {
	var (
		queue []*TreeNode
		ans   [][]int
	)

	//bfs
	if root != nil { // 防空特判
		queue = append(queue, root)
	}
	for len(queue) > 0 {
		levelNode := make([]int, len(queue)) // 每一层节点值
		for i := range levelNode {
			cur := queue[0] // front
			queue = queue[1:]
			levelNode[i] = cur.Val

			if cur.Left != nil {
				queue = append(queue, cur.Left)
			}
			if cur.Right != nil {
				queue = append(queue, cur.Right)
			}
		}
		ans = append(ans, levelNode)
	}

	return ans
}