leetcode
leetcode 651 ~ 700
N 叉树的前序遍历

N 叉树的前序遍历

难度:

标签:

题目描述

给定一个 n 叉树的根节点  root ,返回 其节点值的 前序遍历

n 叉树 在输入中按层序遍历进行序列化表示,每组子节点由空值 null 分隔(请参见示例)。


示例 1:

输入:root = [1,null,3,2,4,null,5,6]
输出:[1,3,5,6,2,4]

示例 2:

输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:[1,2,3,6,7,11,14,4,8,12,5,9,13,10]

 

提示:

  • 节点总数在范围 [0, 104]
  • 0 <= Node.val <= 104
  • n 叉树的高度小于或等于 1000

 

进阶:递归法很简单,你可以使用迭代法完成此题吗?

代码结果

运行时间: 28 ms, 内存: 17.6 MB


/*
题目思路:
1. n叉树的前序遍历是先访问根节点,然后依次访问每个子节点。
2. 使用Java Stream流操作可以简化代码。
3. 对于每个节点,先访问该节点的值,然后使用流操作递归访问子节点。
*/

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

// 定义n叉树节点
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int val) {
        this.val = val;
    }

    public Node(int val, List<Node> children) {
        this.val = val;
        this.children = children;
    }
}

public class Solution {
    public List<Integer> preorder(Node root) {
        if (root == null) return new ArrayList<>();
        return Stream.concat(
                Stream.of(root.val),
                root.children.stream().flatMap(child -> preorder(child).stream())
        ).collect(Collectors.toList());
    }
}

解释

方法:

这道题使用了递归的深度优先搜索(DFS)来完成N叉树的前序遍历。首先初始化结果列表res,如果根节点为空则直接返回空列表。然后定义辅助函数dfs,传入当前节点,如果当前节点为空则直接返回。将当前节点的值加入结果列表,然后对当前节点的所有子节点递归调用dfs。最后在主函数中调用dfs,并返回结果列表res。

时间复杂度:

O(n)

空间复杂度:

O(n)

代码细节讲解

🦆
在递归函数`dfs`中,如果当前节点为空直接返回的情况会在哪种情况下发生,考虑到已经在主函数中检查了根节点是否为空?
在递归函数`dfs`中进行空节点检查实际上是一种防御性编程策略。虽然根节点在主函数中已经进行了检查,但是,N叉树中的某些子节点列表可能为空或包含空节点。例如,一个节点可能显式地持有一个空引用作为其子节点之一。这种情况下,当尝试访问这个空引用的子节点时,就需要这个空检查来防止运行时错误。
🦆
您在递归函数`dfs`中遍历子节点的顺序是否影响了前序遍历的结果?如果是,如何确保结果符合前序遍历的顺序?
在递归函数`dfs`中,子节点的遍历顺序确实影响前序遍历的结果。前序遍历的特点是先访问父节点,然后依次访问子节点。在这种情况下,子节点应当按照从左到右的顺序遍历以保持前序遍历的定义。在代码实现中,应确保子节点列表的遍历是按照这个顺序进行的,如`for c in node.children:`确保了按照列表顺序(通常是插入顺序)进行遍历。
🦆
对于非递归的解决方案,如何使用栈来实现N叉树的前序遍历,并与递归方法在效率上进行比较?
在非递归的解决方案中,可以使用栈来模拟递归过程实现前序遍历。具体方法是,将根节点压入栈中,然后在循环中,从栈中弹出节点,记录其值,然后将其子节点从右至左压入栈中(这样可以保证左侧子节点先被弹出和访问)。这种方法的时间复杂度与递归方法相同,都是O(n),其中n是树中的节点总数。然而,由于递归方法的函数调用可能导致调用栈溢出,使用栈的迭代方法在处理非常深的树时可能更有优势。
🦆
递归深度和N叉树的形状有什么关系?能否举例说明在不同N叉树形状下递归深度的变化?
递归深度直接受N叉树的形状影响。在平衡的N叉树中,每个节点都有相同数量的子节点,并且每层节点数都是前一层的倍数,递归深度相对较小。例如,每个节点有3个子节点的三叉树,高度为h的树的递归深度为h。相反,在极端情况下,如链状结构(每个节点只有一个子节点),树的高度和递归深度等于节点总数,这可能导致非常深的递归调用栈。

相关问题

二叉树的前序遍历

给你二叉树的根节点 root ,返回它节点值的 前序 遍历。

 

示例 1:

输入:root = [1,null,2,3]
输出:[1,2,3]

示例 2:

输入:root = []
输出:[]

示例 3:

输入:root = [1]
输出:[1]

示例 4:

输入:root = [1,2]
输出:[1,2]

示例 5:

输入:root = [1,null,2]
输出:[1,2]

 

提示:

  • 树中节点数目在范围 [0, 100]
  • -100 <= Node.val <= 100

 

进阶:递归算法很简单,你可以通过迭代算法完成吗?

N 叉树的层序遍历

给定一个 N 叉树,返回其节点值的层序遍历。(即从左到右,逐层遍历)。

树的序列化输入是用层序遍历,每组子节点都由 null 值分隔(参见示例)。

 

示例 1:

输入:root = [1,null,3,2,4,null,5,6]
输出:[[1],[3,2,4],[5,6]]

示例 2:

输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

 

提示:

  • 树的高度不会超过 1000
  • 树的节点总数在 [0, 10^4] 之间

N 叉树的后序遍历

给定一个 n 叉树的根节点 root ,返回 其节点值的 后序遍历

n 叉树 在输入中按层序遍历进行序列化表示,每组子节点由空值 null 分隔(请参见示例)。

 

示例 1:

输入:root = [1,null,3,2,4,null,5,6]
输出:[5,6,3,2,4,1]

示例 2:

输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出:[2,6,14,11,7,3,12,8,4,13,9,10,5,1]

 

提示:

  • 节点总数在范围 [0, 104]
  • 0 <= Node.val <= 104
  • n 叉树的高度小于或等于 1000

 

进阶:递归法很简单,你可以使用迭代法完成此题吗?