二叉树的遍历(迭代的方式)

前中后三种遍历

const (
   preorder = int32(iota)
   inorder
   postorder
)

// 迭代遍历
func traverse(root *TreeNode, order int32) (ans []int) {
   stack := make([]*TreeNode, 0)
   var pushLeft func(root *TreeNode)
   pushLeft = func(root *TreeNode) {
      for root != nil {
         //前序位置遍历
         if order == preorder {
            ans = append(ans, root.Val)
         }
         stack = append(stack, root)
         root = root.Left
      }
   }
   visited := &TreeNode{}
   pushLeft(root)
   //若栈里面有数据
   for len(stack) > 0 {
      cur := stack[len(stack)-1]
      //若左节点为空,或者左节点被访问 并且右节点没被访问过
      if (cur.Left == nil || cur.Left == visited) && cur.Right != visited {
         //中序位置
         if order == inorder {
            ans = append(ans, cur.Val)
         }
         pushLeft(cur.Right)
      }
      //若右节点也被访问过了
      if cur.Right == nil || cur.Right == visited {
         visited = cur
         //后序位置
         if order == postorder {
            ans = append(ans, cur.Val)
         }
         stack = stack[:len(stack)-1]
      }
   }
   return ans
}

层序遍历

// 层序遍历
func bfs(root *TreeNode) (ans []int) {
   if root == nil {
      return ans
   }
   queue := make([]*TreeNode, 0)
   queue = append(queue, root)
   for len(queue) > 0 {
      //当前层的节点数
      sz := len(queue)
      for i := 0; i < sz; i++ {
         q := queue[0]
         queue = queue[1:]
         ans = append(ans, q.Val)
         if q.Left != nil {
            queue = append(queue, q.Left)
         }
         if q.Right != nil {
            queue = append(queue, q.Right)
         }
      }
   }
   return ans
}

# 用栈模拟递归迭代遍历二叉树