二叉树的前中后序遍历及N叉树的前后序遍历

最新推荐文章于 2022-12-14 00:40:24 发布

原创最新推荐文章于 2022-12-14 00:40:24 发布 · 669 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树 #数据结构 #算法

数据结构与算法专栏收录该内容

6 篇文章

订阅专栏

本文深入探讨了二叉树的中序遍历及N叉树的前序、后序遍历算法，提供了详细的Golang迭代实现代码，展示了如何不使用递归进行树结构的遍历。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

leetcode原题

94. 二叉树的中序遍历

给定一个二叉树，返回它的中序遍历。

示例:

输入: [1,null,2,3]
1
\
2
/
3

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

递归比较简单，就略过了，直接上迭代代码，这里给出golang的代码

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func inorderTraversal(root *TreeNode) []int {
    if root == nil{
        return []int{}
    }
    ret := []int{}
    m := map[*TreeNode]int{root:1}
    stack := []*TreeNode{root}
    for len(stack) > 0{
        node := stack[len(stack) - 1]
        stack = stack[:len(stack) - 1]
        if v, ok := m[node];ok&&v==1{
            if node.Right != nil{
                stack = append(stack, node.Right)
                m[node.Right] = 1
            }
            stack = append(stack, node)
            m[node] = 2
            if node.Left != nil{
                stack = append(stack, node.Left)
                m[node.Left] = 1
            }
        }else{
            ret = append(ret, node.Val)
        }
    }
    return ret
}

这个是中序遍历，前序、后序遍历只需要调整左右子节点的位置顺序即可

589. N叉树的前序遍历

给定一个 N 叉树，返回其节点值的前序遍历。

例如，给定一个 3叉树 :
在这里插入图片描述

返回其前序遍历: [1,3,5,6,2,4]。

说明: 递归法很简单，你可以使用迭代法完成此题吗?

这里同样给出golang的迭代算法

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Children []*Node
 * }
 */

func preorder(root *Node) []int {
    if root == nil{
        return []int{}
    }
    ret := []int{}
    stack := []*Node{root}
    for len(stack) > 0{
        node := stack[len(stack) - 1]
        stack = stack[:len(stack) - 1]
        ret = append(ret, node.Val)
        for i := len(node.Children) - 1;i>= 0;i--{
            stack = append(stack, node.Children[i])
        }
    }
    return ret
}

590. N叉树的后序遍历

给定一个 N 叉树，返回其节点值的后序遍历。

例如，给定一个 3叉树 :
在这里插入图片描述

返回其后序遍历: [5,6,3,2,4,1].

说明: 递归法很简单，你可以使用迭代法完成此题吗?

/**
 * Definition for a Node.
 * type Node struct {
 *     Val int
 *     Children []*Node
 * }
 */

func postorder(root *Node) []int {
    if root == nil{
        return []int{}
    }
    ret := []int{}
    stack := []*Node{root}
    for len(stack) > 0{
        node := stack[len(stack) - 1]
        stack = stack[:len(stack) - 1]
        ret = append([]int{node.Val}, ret...)
        for i := 0;i < len(node.Children);i++{
            stack = append(stack, node.Children[i])
        }
    }
    return ret
}

以上