树的遍历（二叉树、N叉树）

最新推荐文章于 2023-03-23 02:21:04 发布
最新推荐文章于 2023-03-23 02:21:04 发布
阅读量366 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 二叉树 树结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42638946/article/details/114234602
版权

树的遍历

以Leetcode上面的题目为例演示二叉树、N叉树的递归遍历以及经典非递归遍历方式。

一. 二叉树的遍历

二叉树的定义

  • C++
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;

    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
  • Java
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x){
        val = x;
    }
}

Leetcode 0144 二叉树的前序遍历

问题描述

分析

  • 前序遍历：根左右

代码

  • C++
// 递归
/**
 * 执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
 * 内存消耗：8.2 MB, 在所有 C++ 提交中击败了73.18%的用户
 */
class Solution {
public:
    vector<int> res;

    vector<int> preorderTraversal(TreeNode *root) {
        dfs(root);
        return res;
    }

    void dfs(TreeNode *root) {
        if (!root) return;
        res.push_back(root->val);
        dfs(root->left);
        dfs(root->right);
    }
};

// 非递归
/**
 * 执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
 * 内存消耗：8.2 MB, 在所有 C++ 提交中击败了65.63%的用户
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> res;
        stack<TreeNode *> stk;
        while (root || stk.size()) {
            while (root) {
                res.push_back(root->val);
                stk.push(root);
                root = root->left;
            }
            root = stk.top()->right;
            stk.pop();
        }
        return res;
    }
};
  • Java
/**
 * 递归算法
 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
 * 内存消耗：36.6 MB, 在所有 Java 提交中击败了82.16%的用户
 */
public class Solution {
    ArrayList<Integer> res = new ArrayList<>();

    public List<Integer> preorderTraversal(TreeNode root) {
        dfs(root);
        return res;
    }

    private void dfs(TreeNode root) {
        if (root == null) return;
        res.add(root.val);
        dfs(root.left);
        dfs(root.right);
    }
}

/**
 * 非递归算法
 * 执行用时：1 ms, 在所有 Java 提交中击败了45.75%的用户
 * 内存消耗：36.8 MB, 在所有 Java 提交中击败了30.16%的用户
 */
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {

        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new ArrayDeque<>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                res.add(root.val);
                stk.push(root);
                root = root.left;
            }
            root = stk.pop().right;
        }
        return res;
    }
}

Leetcode 0094 二叉树的中序遍历

问题描述

分析

  • 中序遍历：左根右

代码

  • C++
// 递归
/**
 * 执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
 * 内存消耗：8.2 MB, 在所有 C++ 提交中击败了60.90%的用户
 */
class Solution {
public:
    vector<int> res;

    vector<int> inorderTraversal(TreeNode *root) {
        dfs(root);
        return res;
    }

    void dfs(TreeNode *root) {
        if (!root) return;
        dfs(root->left);
        res.push_back(root->val);
        dfs(root->right);
    }
};

// 非递归
/**
 * 执行用时：4 ms, 在所有 C++ 提交中击败了47.82%的用户
 * 内存消耗：8.1 MB, 在所有 C++ 提交中击败了94.94%的用户
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        stack<TreeNode *> stk;
        while (root || stk.size()) {
            while (root) {
                stk.push(root);
                root = root->left;
            }
            root = stk.top(), stk.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }
};
  • Java
/**
 * 递归算法
 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
 * 内存消耗：36.6 MB, 在所有 Java 提交中击败了70.81%的用户
 */
public class Solution {
    ArrayList<Integer> res = new ArrayList<>();

    public List<Integer> inorderTraversal(TreeNode root) {
        dfs(root);
        return res;
    }

    private void dfs(TreeNode node) {
        if (node == null) return;
        dfs(node.left);
        res.add(node.val);
        dfs(node.right);
    }
}

/**
 * 非递归算法
 * 执行用时：1 ms, 在所有 Java 提交中击败了41.71%的用户
 * 内存消耗：36.9 MB, 在所有 Java 提交中击败了12.74%的用户
 */
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {

        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new ArrayDeque<>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
            root = stk.pop();
            res.add(root.val);
            root = root.right;
        }
        return res;
    }
}

Leetcode 0145 二叉树的后序遍历

问题描述

分析

  • 后序遍历：左右根

代码

  • C++
// 递归
/**
 * 执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
 * 内存消耗：8.1 MB, 在所有 C++ 提交中击败了87.63%的用户
 */
class Solution {
public:
    vector<int> res;

    vector<int> postorderTraversal(TreeNode *root) {
        dfs(root);
        return res;
    }

    void dfs(TreeNode *root) {
        if (!root) return;
        dfs(root->left);
        dfs(root->right);
        res.push_back(root->val);
    }
};

// 非递归
/**
 * 执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户
 * 内存消耗：8.1 MB, 在所有 C++ 提交中击败了94.56%的用户
 */
class Solution {
public:
    // 思路：后序遍历是：左右根，反过来就是：根右左； 按照根右左遍历后，结果再翻转一下即可
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        stack<TreeNode *> stk;
        while (root || stk.size()) {
            while (root) {
                res.push_back(root->val);
                stk.push(root);
                root = root->right;
            }
            root = stk.top()->left;
            stk.pop();
        }
        reverse(res.begin(), res.end());
        return res;
    }
};
  • Java
/**
 * 递归算法
 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
 * 内存消耗：37 MB, 在所有 Java 提交中击败了5.32%的用户
 */
public class Solution {
    ArrayList<Integer> res = new ArrayList<>();

    public List<Integer> postorderTraversal(TreeNode root) {
        dfs(root);
        return res;
    }

    private void dfs(TreeNode node) {
        if (node == null) return;
        dfs(node.left);
        dfs(node.right);
        res.add(node.val);
    }
}

/**
 * 非递归算法
 * 执行用时：1 ms, 在所有 Java 提交中击败了53.31%的用户
 * 内存消耗：36.7 MB, 在所有 Java 提交中击败了54.95%的用户
 */
public class Solution {
    // 思路：后序遍历是：左右根，反过来就是：根右左； 按照根右左遍历后，结果再翻转一下即可
    public List<Integer> postorderTraversal(TreeNode root) {

        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new ArrayDeque<>();
        while (null != root || !stk.isEmpty()) {
            while (null != root) {
                res.add(root.val);
                stk.push(root);
                root = root.right;
            }
            root = stk.pop().left;
        }
        Collections.reverse(res);
        return res;
    }
}

Leetcode 0102 二叉树的层序遍历

问题描述

分析

  • 层序遍历：逐层地，从左到右访问所有节点

代码

  • C++
/**
 * 执行用时：4 ms, 在所有 C++ 提交中击败了89.06%的用户
 * 内存消耗：11.3 MB, 在所有 C++ 提交中击败了97.27%的用户
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode *root) {

        vector<vector<int>> res;
        queue<TreeNode *> q;
        if (root) q.push(root);
        while (q.size()) {
            vector<int> level;
            int len = q.size();

            while (len--) {
                auto t = q.front();
                q.pop();
                level.push_back(t->val);
                if (t->left) q.push(t->left);
                if (t->right) q.push(t->right);
            }
            res.push_back(level);
        }
        return res;
    }
};
  • Java
/**
 * 执行用时：1 ms, 在所有 Java 提交中击败了94.42%的用户
 * 内存消耗：38.8 MB, 在所有 Java 提交中击败了21.83%的用户
 */
public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> q = new LinkedList<>();
        if (root != null) q.add(root);
        while (!q.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int len = q.size();
            for (int i = 0; i < len; i++) {
                TreeNode t = q.remove();
                level.add(t.val);
                if (t.left != null) q.add(t.left);
                if (t.right != null) q.add(t.right);
            }
            res.add(level);
        }
        return res;
    }
}

二. N叉树的遍历

N叉树的定义

  • C++
class Node {
public:
    int val;
    vector<Node *> children;
    Node() {}
    Node(int _val) { val = _val; }
    Node(int _val, vector<Node *> _children) {
        val = _val;
        children = _children;
    }
};
  • Java
public 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;
    }
};

Leetcode 0589 N叉树的前序遍历

问题描述

分析

  • N叉树的前序遍历：根，从左到右遍历该根对应的孩子

代码

  • C++
// 递归
/**
 * 执行用时：16 ms, 在所有 C++ 提交中击败了96.71%的用户
 * 内存消耗：11.3 MB, 在所有 C++ 提交中击败了62.70%的用户
 */
class Solution {
public:
    vector<int> res;

    vector<int> preorder(Node *root) {
        dfs(root);
        return res;
    }

    void dfs(Node *root) {
        if (!root) return;
        res.push_back(root->val);
        for (auto c : root->children)
            dfs(c);
    }
};

// 非递归
/**
 * 执行用时：28 ms, 在所有 C++ 提交中击败了64.12%的用户
 * 内存消耗：11.2 MB, 在所有 C++ 提交中击败了72.09%的用户
 */
class Solution {
public:
    vector<int> preorder(Node *root) {
        vector<int> res;
        stack<Node *> stk;
        if (root) stk.push(root);
        while (stk.size()) {
            auto t = stk.top(); stk.pop();
            res.push_back(t->val);
            reverse(t->children.begin(), t->children.end());
            for (auto c : t->children) {
                if (c) stk.push(c);
            }
        }
        return res;
    }
};
  • Java
/**
 * 递归
 * 执行用时：1 ms, 在所有 Java 提交中击败了95.48%的用户
 * 内存消耗：39.6 MB, 在所有 Java 提交中击败了56.39%的用户
 */
public class Solution {
    List<Integer> res = new ArrayList<>();

    public List<Integer> preorder(Node root) {
        dfs(root);
        return res;
    }

    private void dfs(Node root) {
        if (root == null) return;
        res.add(root.val);
        if (root.children != null)
            for (Node child : root.children)
                dfs(child);
    }
}

/**
 * 非递归
 * 执行用时：5 ms, 在所有 Java 提交中击败了16.09%的用户
 * 内存消耗：39.7 MB, 在所有 Java 提交中击败了38.13%的用户
 */
public class Solution {
    public List<Integer> preorder(Node root) {

        List<Integer> res = new ArrayList<>();
        Deque<Node> stk = new ArrayDeque<>();
        if (root != null) stk.push(root);
        while (!stk.isEmpty()) {
            Node t = stk.pop();
            res.add(t.val);
            if (t.children != null) {
                Collections.reverse(t.children);
                for (Node child : t.children)
                    if (child != null)
                        stk.push(child);
            }
        }
        return res;
    }
}

Leetcode 0590 N叉树的后序遍历

问题描述

分析

  • N叉树的前序遍历：从左到右遍历该根对应的孩子，然后遍历根

  • 思路：类似于二叉树的后续遍历，我们可以按如下方式解决：

    （1） 按照 根 子节点n ... 子节点2 子节点1 方式遍历

    （2） 翻转得到结果

代码

  • C++
// 递归
/**
 * 执行用时：20 ms, 在所有 C++ 提交中击败了87.55%的用户
 * 内存消耗：11.3 MB, 在所有 C++ 提交中击败了61.37%的用户
 */
class Solution {
public:
    vector<int> res;

    vector<int> postorder(Node *root) {
        dfs(root);
        return res;
    }

    void dfs(Node *root) {
        if (!root) return;
        for (auto c : root->children)
            dfs(c);
        res.push_back(root->val);
    }
};

// 非递归
/**
 * 执行用时：24 ms, 在所有 C++ 提交中击败了72.41%的用户
 * 内存消耗：11.2 MB, 在所有 C++ 提交中击败了79.58%的用户
 */
class Solution {
public:
    vector<int> postorder(Node *root) {
        vector<int> res;
        stack<Node *> stk;
        if (root) stk.push(root);
        while (stk.size()) {
            auto t = stk.top(); stk.pop();
            res.push_back(t->val);
            for (auto c : t->children) {
                if (c) stk.push(c);
            }
        }
        reverse(res.begin(), res.end());
        return res;
    }
};
  • Java
/**
 * 递归
 * 执行用时：1 ms, 在所有 Java 提交中击败了96.32%的用户
 * 内存消耗：39.7 MB, 在所有 Java 提交中击败了56.65%的用户
 */
public class Solution {
    List<Integer> res = new ArrayList<>();

    public List<Integer> postorder(Node root) {
        dfs(root);
        return res;
    }

    private void dfs(Node root) {
        if (root == null) return;
        if (root.children != null)
            for (Node child : root.children)
                dfs(child);
        res.add(root.val);
    }
}

/**
 * 非递归
 * 执行用时：4 ms, 在所有 Java 提交中击败了40.11%的用户
 * 内存消耗：39.4 MB, 在所有 Java 提交中击败了47.68%的用户
 */
public class Solution {
    public List<Integer> postorder(Node root) {

        List<Integer> res = new ArrayList<>();
        Deque<Node> stk = new ArrayDeque<>();
        if (root != null) stk.push(root);
        while (!stk.isEmpty()) {
            Node node = stk.pop();
            res.add(node.val);
            if (node.children != null)
                for (Node child : node.children)
                    if (child != null)
                        stk.push(child);
        }
        Collections.reverse(res);
        return res;
    }
}

Leetcode 0429 N叉树的层序遍历

问题描述

分析

  • N叉树的层序遍历：逐层地，从左到右访问所有节点

代码

  • C++
/**
 * 执行用时：20 ms, 在所有 C++ 提交中击败了84.18%的用户
 * 内存消耗：11.4 MB, 在所有 C++ 提交中击败了97.76%的用户
 */
class Solution {
public:
    vector<vector<int>> levelOrder(Node *root) {

        vector<vector<int>> res;
        if (!root) return res;
        queue<Node *> q;
        q.push(root);
        while (q.size()) {
            int len = q.size();
            vector<int> line;
            while (len--) {
                auto t = q.front(); q.pop();
                line.push_back(t->val);
                for (auto c : t->children)
                    q.push(c);
            }
            res.push_back(line);
        }
        return res;
    }
};
  • Java
/**
 * Created by WXX on 2021/2/28 18:04
 * 执行用时：4 ms, 在所有 Java 提交中击败了45.55%的用户
 * 内存消耗：39.3 MB, 在所有 Java 提交中击败了70.71%的用户
 */
public class Solution {

    public List<List<Integer>> levelOrder(Node root) {

        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res;
        Queue<Node> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            int len = q.size();
            List<Integer> line = new ArrayList<>();
            while (len-- != 0) {
                Node t = q.remove();
                line.add(t.val);
                if (t.children != null)
                    for (Node c : t.children)
                        q.add(c);
            }
            res.add(line);
        }
        return res;
    }
}
你好世界wxx
关注
专栏目录
二叉树 n叉树 遍历算法
xiangminlu的博客
09-22 227
二叉树 // 二叉树的遍历 class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } public class pre { List<Integer> treeList=new ArrayList(); public static void main(String[] args) { }
二叉树及n叉树的层序遍历，看这一篇就够
神仙菜ccc的博客
04-18 1002
关于Leetcode上二叉树及n叉树的层序遍历 层序遍历二叉树，顾名思义，就是从左到右一层一层的去遍历二叉树。 通常需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。 而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。 下面上题目: 题面及样例输入输出： 题目来源：leetcode（力扣） 题目链接：https://leetcode-cn.com/problems/binary-tree-level-orde
429. N 叉树的层序遍历
s11235218的博客
08-07 285
429. 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,nu
【LeetCode】429. N 叉树的层序遍历
记录、总结
02-18 278
题目描述： 给定一个 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] 输出：[[
力扣——N叉树的层序遍历
weixin_30314631的博客
04-03 148
给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个3叉树: 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 说明: 树的深度不会超过1000。 树的节点总数不会超过5000。 /* // Definition for a Node. clas...
二叉树之N叉树
Anora的博客
09-02 305
Leetcode02--二叉树之N叉树T589. N叉树的前序遍历T590 N叉树的后序遍历T429N叉树的层序遍历 T589. N叉树的前序遍历 给定一个 N 叉树，返回其节点值的前序遍历。 class Solution { public List<Integer> preorder(Node root) { if(root==null)return new ArrayList<Integer>(); List<Integ
N叉树遍历所有路径
weixin_49150294的博客
09-04 1224
声明：这是本人的第一篇博客，主要用于自己的笔记，如有错误纯属正常，希望得到大佬的指导。 最近在学数据结构，需要用到三叉树遍历所有路径，研究了好几天找了很多方法都没实现，最后在LeetCode上研究了一下“二叉树遍历所有路径”，最后发现与N叉树遍历所有路径道理完全相同，下面与大家分享一下主要的思想，并给出实现代码，供大家参考。 1.三叉树结构体 struct TreeNode { int val; TreeNode* left; TreeNode* mid; TreeNode* right;
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
N叉树的遍历（C++）
bulangman277的博客
12-17 1751
这两道N叉树的题，让我不仅仅局限于二叉树，眼界放的更开了。并且又复习了一遍深度优先遍历（包括前序遍历和后序遍历）和递归解法的设计。 个人认为非常有价值。
递归理解三：深度、广度优先搜索，n叉树遍历，n并列递归理解与转非递归
最新发布
qq_23095607的博客
03-23 690
由前面二叉树的遍历规律和递归的基本原理，我们可以看到，二叉树遍历口诀和二叉树递推公式有着紧密的联系前序遍历：F(x) =op1(x)根左右中序遍历：F(x) = F(x左) &op1(x)&F(x右) 口诀：左根右后序遍历：F(x) = F(x左) & F(x右) &op1(x)口诀：左右根其中op1(x)表示对数据X的操作如果上述公式中，将op1(x)看做根，可以发现递推公式和口诀是一摸一样的。
二叉树、N叉树
疯狂的蜗牛
10-16 303
429. 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,
Leetcode 429. N叉树的层序遍历
一个小白的日常
03-02 698
题目： 给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个 3叉树 : 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 说明: 树的深度不会超过 1000。 树的节点总数不会超过 5000。 方法一： 思路：用队列实现，把每一层的Node压入队列。 时间：10ms 代码： public List&lt;List&lt;Integer&gt...
leetcode：429. N叉树的层序遍历
OceanStar的博客
11-20 263
题目来源 429. N叉树的层序遍历 题目描述 题目解析 队列 /* // 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> _c
LeetCode429.N叉树的层序遍历
qq_39241239的博客
01-30 169
题目来源： https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/ 题目描述： 代码如下： /* // Definition for a Node. class Node { public int val; public List&lt;Node&gt; children; publ...
leetcode429. N叉树的层序遍历
一条特立独行的狗、的博客
09-15 176
给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个 3叉树 : 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 说明：涉及到层次遍历可以用queue（利用队列的先进先出原则）来处理，每处理一层就记录下一层的节点，并删掉当前这层的节点，这样可以保证所有节点都是层次遍历的结果。 /* // Definition for a Node. class Node { public: int val; vector<Node*> ch
[Tree Breadth First Search] N叉树的层序遍历
编程菜汝狗
07-27 185
leetcode 429，N-ary Tree Level Order Traversal，难度medium； 0. 题干 给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个 3叉树 : 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 说明: 树的深度不会超过 1000。 树的节点总数不会超过 5000。 1. 代码 /* // Definition for a Node. class Node { public: int val;
Java——N叉树的层序遍历
m0_60867520的博客
03-05 609
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
【LeetCode】N叉树的层序遍历
ly_6699的博客
08-11 321
题目描述 给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个 3叉树 : 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 说明: 树的深度不会超过 1000。 树的节点总数不会超过 5000。 解题思路 用两个队列，一个队列存节点的value值，另一个队列存节点的层数，节点队列出队的将它的孩子节点和层数带入队列，并且当前节点的层数...
1533. N叉树的层序遍历
时代我西的博客
06-18 125
1533.N叉树的层序遍历 给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个3叉树: 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 样例 样例 1: 输入：{1,3,2,4#2#3,5,6#4#5#6} 输出：[[1],[3,2,4],[5,6]] 解释：如上图 样例 2: 输入：{1,3,2#2#3} 输出：[[1],[3,2]] 解释： 1 / \ 3 2 ...
树和二叉树遍历算法详解
此外，除了二叉树，还有更一般化的树结构，如n叉树。它们的遍历方式类似，但根据节点的孩子数量会有不同的遍历策略。树和森林的遍历也是树理论中的重要部分，它们对于理解和操作复杂数据结构至关重要。 遍历算法在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值