题目描述：
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
思路分析：
递归法：
前序遍历的顺序是中左右的顺序。那么每个子树都是这个顺序，所以可以使用递归进行遍历。递归遍历有3部曲
1.确定递归函数的参数和返回值。
因为返回值要求保存在一个数组中，所以递归函数的参数应该包括树的根节点和结果数组
` func preOrder(root *TreeNode,res *[]int) `
2.确定递归函数的终止条件
对于前序遍历来说，当某个根节点没有孩子节点的时候终止遍历。
```
if root==nil {
return
} ```
3.确定单层递归的逻辑
按照顺序进行遍历即可。
*res = append(*res, root.Val)
preOrder(root.Left,res)
preOrder(root.Right,res)
最终的代码为：
点击查看代码
func preorderTraversal(root *TreeNode) []int {
// 递归函数3步骤：
// 1.确定递归函数的参数 2.确定递归函数的停止条件 3.确定单层递归的调用逻辑
var res []int
preOrder(root,&res)
return res
}
func preOrder(root *TreeNode,res *[]int){
if root==nil {
return
}
*res = append(*res, root.Val)
preOrder(root.Left,res)
preOrder(root.Right,res)
}
中序遍历：
点击查看代码
func inorderTraversal(root *TreeNode) []int {
var res []int
if root==nil{
return res
}
getOrder(root,&res)
return res
}
func getOrder(root *TreeNode, res *[]int) {
if root!=nil {
getOrder(root.Left,res)
*res = append(*res, root.Val)
getOrder(root.Right,res)
}
}
后序遍历：
点击查看代码
func postorderTraversal(root *TreeNode) []int {
var res []int
postOrder(root,&res)
return res
}
func postOrder(root *TreeNode,res *[]int) {
if root==nil{
return
}
postOrder(root.Left,res)
postOrder(root.Right,res)
*res = append(*res, root.Val)
}
非递归版本
上方是三种遍历的递归方式，一定要明确递归的3个步骤。但是递归一般复杂度高，很难解决数据量大的数据。在计算机中递归就是用栈实现的，所以我们可以用栈来实现递归函数的非递归版本。但是三种遍历方式的写法会有区别。
三种遍历的非递归其实都是从根节点开始按照根左右的方式入栈，区别就在于什么时候应该出栈。
前序遍历
前序遍历的顺序是根左右，由于是栈来实现，所有实际的入栈顺序是根右左，当访问到根的时候将根节点入栈--记录其值，然后将根节点出栈，按照根节点的右左孩子的顺序入栈，再根据栈顶元素作为根节点进行处理。函数结束条件则是栈的长度大于0.
点击查看代码
func preorderTraversal(root *TreeNode) []int{
var res []int
if root==nil{
return res
}
var stack []*TreeNode
stack = append(stack, root)
for len(stack)>0 {
node:=stack[len(stack)-1]
stack = stack[:len(stack)-1]
if node!=nil {
res = append(res, node.Val)
}
if node.Right != nil {
stack = append(stack, node.Right)
}
if node.Left!=nil {
stack = append(stack, node.Left)
}
}
return res
}
中序遍历
中序的遍历顺序是左中右。
入栈顺序：从根节点开始，首先将当前节点的左子树一路压入栈中，直到当前节点没有左子树为止。
出栈条件：当栈顶节点没有左子树时，出栈该节点并访问它，然后继续对其右子树进行遍历。
函数结束条件是 root!=nil || len(stack)>0 这是因为当遍历完左子树之后，回溯到整个树的root的时候，栈已经空了，但是右子树还没有入栈，所以还需要判断root是否为空。
点击查看代码
func inorderTraversal(root *TreeNode) []int{
if root==nil {
return []int{}
}
res,stack:=[]int{},[]*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.Val)
// 遍历右子树
root = root.Right
}
return res
}
后序遍历
后序遍历的顺序是：左-右-根。
入栈顺序： 从根节点开始，首先将当前节点压入栈中，然后按照“左右”的顺序将节点的左孩子和右孩子压入栈中。
出栈条件： 每次出栈栈顶元素后，仅在左右子树都已访问完成的情况下才访问根节点。为了保证这一点，通常需要借助一个额外的标记。所以我们通过pre指针来判断左右孩子是否已经访问过，只有他们都被访问过才能访问根节点。
因为入栈顺序，所以栈顶元素必然是叶子节点，通过prev记录上一次访问的节点，如果当前节点是叶子节点，直接记录；若不是叶子节点，如果prev是当前节点的任一孩子，说明孩子节点访问完毕「2种情况，2个孩子和只有一个孩子，模拟一下便知」，则可以访问根节点了。
点击查看代码
func postorderTraversal(root *TreeNode) []int{
if root==nil{
return []int{}
}
res,stack := []int{},[]*TreeNode{}
var prev *TreeNode
stack = append(stack, root)
for len(stack)>0{
current:=stack[len(stack)-1]
if(current.Left== nil && current.Right ==nil) || (prev!=nil && (prev == current.Left || prev==current.Right)){
res = append(res, current.Val)
stack = stack[:len(stack)-1]
prev = current
}else{
if current.Right!=nil {
stack = append(stack, current.Right)
}
if current.Left != nil {
stack = append(stack, current.Left)
}
}
}
return res
}