代码随想录算法训练营|day14

最新推荐文章于 2024-09-29 16:46:50 发布

果木26

最新推荐文章于 2024-09-29 16:46:50 发布

阅读量863

点赞数 31

分类专栏：代码随想录练习文章标签：算法 go

本文链接：https://blog.csdn.net/weixin_43785190/article/details/135765156

版权

代码随想录练习专栏收录该内容

43 篇文章 0 订阅

订阅专栏

本文详细介绍了二叉树的中序、前序和后序遍历，分别提供了递归和迭代两种实现方式，强调了在解决问题时多思考和提问的重要性。

摘要由CSDN通过智能技术生成

第六章二叉树

遍历方法详解
94.二叉树的中序遍历
144.二叉树的前序遍历
145.二叉树的后序遍历
总结

遍历方法详解

1. 递归遍历 2. 迭代遍历 3. 统一迭代

94.二叉树的中序遍历

(1)递归

func inorderTraversal(root *TreeNode) []int {
    res :=[]int{}
    inorder(root, &res)
    return res
}

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

(2)迭代

主要思路：
左子树一直压栈，直到没有子节点，记录结果，弹出，遍历右子树

func inorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    stack := []*TreeNode{}
    node := root 
    for len(stack) > 0 || node != nil {
        for node != nil {
            stack = append(stack, node)
            node = node.Left
        }
        node = stack[len(stack) - 1]
        res = append(res, node.Val)
        stack = stack[:len(stack) - 1]
        node = node.Right
    }
    return res
}

144.二叉树的前序遍历

(1)递归

func preorderTraversal(root *TreeNode) []int {
    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)
}

(2)迭代

主要思路：
左子树压栈并记录结果，直到没有子节点，弹出，遍历右子树

func preorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    stack := []*TreeNode{}
    node := root
    for len(stack) > 0 || node != nil {
        for node != nil {
            res = append(res, node.Val)
            stack = append(stack, node)
            node = node.Left
        }
        node = stack[len(stack) - 1].Right
        stack = stack[:len(stack) - 1]
    }
    return res
}

145.二叉树的后序遍历

(1)递归

func postorderTraversal(root *TreeNode) []int {
    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)
}

(2)迭代

主要思路：
右左子树压栈并记录结果，直到没有子节点，弹出，遍历左子树，最后反转结果

func postorderTraversal(root *TreeNode) []int {
    res := []int{}
    if root == nil {
        return res
    }
    stack := []*TreeNode{}
    node := root 
    for len(stack) > 0 || node != nil {
        for node != nil {
            res = append(res, node.Val)
            stack = append(stack, node)
            node = node.Right
        }
        node = stack[len(stack) - 1].Left
        stack = stack[:len(stack) - 1]
    }
    Reverse(res)
    return res
}

func Reverse(s interface{})  {
    sort.SliceStable(s, func(i, j int) bool {
        return true
    })
}