590. N 叉树的后序遍历 / 145. 二叉树的后序遍历 / 429. N 叉树的层序遍历 / 102. 二叉树的层序遍历-CSDN博客

本文链接：https://blog.csdn.net/weixin_42593011/article/details/123437922

590. N 叉树的后序遍历【简单题】【每日一题】

思路：【递归】

定义list集合用来存储答案，定义dfs函数用来遍历N叉树。
当前节点不为空时，遍历当前节点的所有子节点，并将子节点传入dfs函数递归调用，当传入的节点没有子节点时，调用dfs函数为直接返回，返回之后将当前节点的值添加到list中，之后返回上一层递归，即调用与当前节点在同一层的其他节点。
所有节点遍历完，返回list即为答案。

代码：

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> list = new ArrayList();
        dfs(root,list);
        return list;
    }
    public void dfs(Node root,List<Integer> list){
        if(root == null){
            return;
        }
        for(Node node : root.children){
            dfs(node,list);
        }
        list.add(root.val);
    }
}

145. 二叉树的后序遍历【简单题】

思路：【递归】

与上题一样思路。
定义list用来存储答案，定义dfs函数用来遍历二叉树。
如果传入的节点为空，直接返回，否则，dfs递归调用当前节点的左子节点和右子节点，如果当前节点既没有左子节点又没有右子节点，则将当前节点的值添加到list中，并回到上一层递归函数中。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        dfs(root,list);
        return list;
    }
    public void dfs(TreeNode root,List<Integer> list){
        if(root == null){
            return;
        }
        dfs(root.left,list);
        dfs(root.right,list);
        list.add(root.val);
    }
}

429. N 叉树的层序遍历【中等题】

思路：【递归+BFS】

按层对N叉树进行遍历，设根节点为第一层。
如果根节点为空，那么直接返回空的list集合，如果不为空，则将根节点，list，与当前层数deepth=1传入bfs中开始递归。
如果当前list集合的长度小于层数，就在list集合里边添加一个元素，用来存储当前层的节点值，其在list中的下标刚好与层数depth存在下标=depth-1的关系。
将当前节点的值存入当前层集合。
遍历当前节点的所有子节点，递归调用bfs函数，传入的层数为depth+1，传入的节点为当前子节点。

代码：

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> list = new ArrayList<>();
        if(root != null){
            bfs(list,root,1);   
        }
        return list; 
    }
    public void bfs(List<List<Integer>> list,Node root,int depth){
        if(list.size() < depth){
            list.add(new ArrayList<>());
        }
        list.get(depth-1).add(root.val);
        for(Node node : root.children){
            bfs(list,node,depth+1);
        }
    }
}

102. 二叉树的层序遍历【中等题】

思路：【递归+BFS】

思路：

与上题思路一致，如果根节点不为空，则调用bfs函数进行递归遍历。
如果list集合的长度小于层数depth，那么需要在list中添加一个元素用来存储当前层的节点值。
将当前节点值添加入当前层，并依次递归调用bfs函数判断当前节点的左子节点和右子节点，此时需要注意左子节点和右子节点不为空的情况下才能调用bfs，否则会报空指针异常。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        if(root != null){
            bfs(list,1,root);
        }
        return list;
    }
    public void bfs(List<List<Integer>> list,int depth,TreeNode root){
        if(list.size() < depth){
            list.add(new ArrayList<>());
        }
        list.get(depth-1).add(root.val);
        if(root.left != null){
            bfs(list,depth+1,root.left);
        }
        if(root.right != null){
            bfs(list,depth+1,root.right);
        }
    }
}