刷题笔记day14-二叉树01

前序遍历

前序遍历的方式是：根节点、左节点、右节点。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
import "container/list"

func preorderTraversal(root *TreeNode) []int {
    // 思路1：使用递归的方法。三要素：返回条件和参数，单层的逻辑。
    // 思路2：层次遍历：使用栈。根左右
    result := []int{}
    if root == nil {
        return result
    }
    stack := list.New()
    stack.PushBack(root)
    for stack.Len() != 0 {
        top := stack.Remove(stack.Back())
        node := top.(*TreeNode)
        result = append(result, node.Val)
        
        if node.Right != nil {
            stack.PushBack(node.Right)
        }
        if node.Left != nil {
            stack.PushBack(node.Left)
        }
    }
    return result
}

中序遍历

中序遍历的思路是，左节点、根节点、右节点。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
import "container/list"
func inorderTraversal(root *TreeNode) []int {
    // 思路1：中序遍历，左、根、右。使用栈
    result := []int{}
    stack := list.New()
    curr := root
    for curr != nil || stack.Len() > 0 {
        // 左左入栈
        if curr != nil {
            stack.PushBack(curr)
            curr = curr.Left
            continue
        } 
        top := stack.Remove(stack.Back())
        node := top.(*TreeNode)
        // 左中节点存入结果
        result = append(result, node.Val)
        // 访问右子树
        if node.Right != nil {
            curr = node.Right
        }
    }
    return result
}

后序遍历

前序遍历是：根左右，翻转就是右左根。如果是根右左，翻转就是左右根了

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
import (
    "container/list"
)

func postorderTraversal(root *TreeNode) []int {
    // 思路：后序遍历：左、右、根
    // 前序遍历是：根左右，翻转就是右左根。如果是根右左，翻转就是左右根了
    result := []int{}
    if root == nil {
        return result
    }
    stack := list.New()
    stack.PushBack(root)
    for stack.Len() > 0 {
        top := stack.Remove(stack.Back())
        node := top.(*TreeNode)
        result = append(result, node.Val)
        if node.Left != nil {
            stack.PushBack(node.Left)
        }
        if node.Right != nil {
            stack.PushBack(node.Right)
        }
    }
    // 倒序排序
    newResult := []int{}
    for i := len(result) - 1; i >= 0; i-- {
        newResult = append(newResult, result[i])
    }
    return newResult

}