树-层序遍历的迭代写法

最新推荐文章于 2025-06-16 09:27:21 发布
原创 最新推荐文章于 2025-06-16 09:27:21 发布 · 312 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种实现二叉树层序遍历的方法，采用队列来辅助完成遍历过程。首先创建一个队列并将根节点放入队列中，然后开始循环处理直到队列为空。每次循环都会处理当前层的所有节点，并将它们的值存入一个临时列表中，同时将下一层的节点加入队列。最后将每一层的节点值列表加入结果列表中。

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

一、代码实现

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

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>> ret = new ArrayList<List<Integer>>();
//        if (root == null) {
//            return ret;
//        }
//
//        Queue<TreeNode> queue = new LinkedList<TreeNode>();
//        queue.offer(root);
//        while (!queue.isEmpty()) {
//            List<Integer> level = new ArrayList<Integer>();
//            int currentLevelSize = queue.size();
//            for (int i = 1; i <= currentLevelSize; ++i) {
//                TreeNode node = queue.poll();
//                level.add(node.val);
//                if (node.left != null) {
//                    queue.offer(node.left);
//                }
//                if (node.right != null) {
//                    queue.offer(node.right);
//                }
//            }
//            ret.add(level);
//        }
//
//        return ret;
//    }
//}

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        //思路 二叉树的层序遍历 通用思路为使用 队列，利用队列先进先出特点保存每一行的结点，遍历之后出队
        //时间复杂度 空间复杂度 O(n)
        List<List<Integer>> res = new ArrayList<>();

        if(root == null){
            return res;
        }
        //存储每层结点队列
        Queue<TreeNode> queueNodes = new LinkedList<>();
        //把当前根节点加入队列
        queueNodes.add(root);

        //遍历队列节点

        while(!queueNodes.isEmpty()){
            //获取当前层级有多少个节点
            int count = queueNodes.size();
            //保存当前遍历节点值得 list
            List<Integer> temp = new ArrayList<>();
            //根据队列中的数据 遍历获取节点值
            for (int i = 0; i < count; i++) {
                //当前节点是否有左右子节点
                if(queueNodes.peek().left !=null){
                    queueNodes.offer(queueNodes.peek().left);
                }
                if(queueNodes.peek().right !=null){
                    queueNodes.offer(queueNodes.peek().right);
                }
                //保存当前节点行元素值数组 并从队列中删除
                temp.add(queueNodes.poll().val);
            }
            //保存每一层节点数组
            res.add(temp);
        }

        return res;
    }
}

class test{
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(5);
        TreeNode node6 = new TreeNode(6);
        TreeNode node7 = new TreeNode(7);
        node1.left = node2;node1.right = node3;
        node2.left = node4;node2.right = node5;
        node3.left = node6;node3.right = node7;
        List<List<Integer>> res = new ArrayList<>();
        res = new Solution().levelOrder(node1);
        for (int i = 0; i < res.size(); i++) {
            System.out.println(res.get(i));
        }
    }
}

二、通过层序遍历学到了什么？

1、队列的定义
Queue<> queue = new ArrayList<>();
2、使用队列实现层序遍历
3、层序遍历输出的是存放列表的列表，每个列表代表每一层；

C++实现二叉树的前中后层序遍历（递归和迭代）
小麦China的博客
02-06 829
C++实现二叉树的前中后和层序遍历（递归和非递归写法） 参考以下图解，这个文章写得真好 ———————————————— 版权声明：本文为优快云博主「Monster_ii」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.youkuaiyun.com/monster_ii/article/details/82115772 ...
【数据结构】二叉树的前中序遍历及层序遍历
Patrick_yuxuan的博客
04-07 1141
我们使用指针一直向左遍历，当前节点不为空时，将其入栈并将当前节点移动到其左子节点。当前节点为空时，表示左子树遍历完成，出栈并将父节点存入结果数组，然后将当前节点移动到父节点的右子节点。具体实现是：根节点入队，然后当队列不为空时，读取队列长度，依据队列长度得到该层节点数目，遍历当前层节点依次出队，并将他们的左右孩子入队，然后重复该操作，直至队列为空，也就是到达最后一层再没有节点了。我们先把根节点入栈出栈，然后先入栈右孩子，在入栈左孩子，这样子就能实现左孩子先出栈，右孩子后出栈。，此时将数组反转，就能得到。
树的层序遍历
errors_F的博客
04-10 3529
突然想到写这个的原因是在四月份的每日一题里面有一个n叉树的层序遍历，然后自己做的其实不熟练。又想到之前又写过二叉树的层序遍历，所以就想着将几个题目一起总结起来。也算是加深一下印象了。 树的遍历方法一共四种： 先序遍历、中序遍历、后序遍历、层序遍历。 前三种方法中的序是指根节点的遍历顺序，一般使用递归（深度优先遍历）的方法实现。 层序遍历是指从最上层开始，一层一层的从左到右遍历，而不再是先左后右或先右后左。 层序遍历和广度优先搜索的思路比较像，维护一个队列，先将根结点放入队列中，当该结点出队列是，他的孩子结点
层序遍历迭代法
zhaoyan123477的博客
07-13 266
思想：BFS遍历方法 用队列思想，存储每一层结点，第一层入队列，第二层出队列。 Queue a=new ArrayDeque<>(); 判断root是否为空，不为空则入队列。 判断队列是否为空，不为空则执行循环。 定义每一层的大小n,引入一个list对象 level 出队元素存到level中。之后分别将左子树和右子树入队列。 class Solution { public List<List<Integer>> levelOrder(TreeNode root)
算法系列之树的层序遍历
weixin_42125125的博客
06-16 266
小伙伴们大家好呀！又给大家可以讲解算法题目了。前面我们讲解了先根、中根、后根遍历，今天我们来介绍另一种常见的。历方式层序遍历。层序遍历顾名思义就是按层一层层遍历定义二叉树char val;
leetcode--二叉树的层序遍历（迭代法）
navylhjjlh的博客
04-15 1239
leetcode--二叉树的层序遍历（C语言）
迭代法实现二叉树的层序遍历
weixin_64595402的博客
09-19 310
BFS在二叉树中的应用
二叉树的遍历（迭代写法）
weixin_43860460的博客
07-17 299
前序遍历 顺序 根 左 右 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { public: vector<int>
二叉树层序遍历分层[递归迭代两种思想+三种解法]
qq_43164662的博客
05-03 1587
层序遍历作为二叉树遍历的基本遍历，一般来说只能用迭代来解。但是分层输出则既可用迭代，又可配合level用前序遍历来解。
Java中的二叉树，前中后序遍历的递归和迭代写法。
回水的博客
06-15 1366
文章目录一、树是什么？树的特点二、二叉树1.概念及特点2.读入数据总结 一、树是什么？ 树是一种非线性的数据结构，它是由n(n >= 0)个有限结点组成的一个具有层次关系的集合。(线性数据结构就是：线性表，数组，栈，链表，队列，字符串…元素之间逻辑上一个挨着一个，呈值直线排列)把它叫做树是因为它看起来像一颗倒着的树，意思就是根朝上，叶子朝下。 树的特点 有一个特殊的结点，称为根节点，根节点没有前驱结点。 除根节点外，其余节点被分成M(M > 0) 个互不相交的集合T1、T2、…、Tm,其中
二叉树篇1-遍历-递归遍历，栈遍历的使用
weixin_45601578的博客
02-21 700
本篇的重点是比较并理解递归与迭代的写法。 先验: 关于二叉树的概念，种类在STL容器篇中说明过，因此这里直接用
遍历二叉树的迭代写法
zzh
02-22 410
使用递归遍历二叉树一般比较简单，使用迭代较难。这两种方法是等价的，不同之处在于递归时隐式维护了一个栈，而迭代时则要显示地将这个栈模拟出来。 1.前序遍历 前序遍历时中左右的遍历顺序，处理时先将根节点压入栈中，然后处理根节点，将右孩子先压入栈中，再将左孩子压入栈中(处理时先左后右，故入栈顺序为先右后左) vector<int> preorderTraversal(TreeNode* root){ stack<TreeNode*> stk; vector<int>
树的三种遍历方法(迭代算法）
qq_41904699的博客
09-22 1345
树的三种遍历方式中序遍历前序遍历后序遍历 中序遍历 Leecode94，当根节点遍历完成的时候，需要根节点进行中转到右子树 import java.util.ArrayDeque; import java.util.ArrayList; import java.util.List; public class Solution { public static void main(String[] args) { TreeNode t1 = new TreeNode(1);
关于二叉树的三种遍历的迭代写法
Seqlist_base的博客
05-15 489
前几天在leetcode上看到一位大佬写的二叉树的迭代写法，博主觉得非常好记实用便记录下来。 struct TreeNode{ TreeNode *right,*left; int val; } 先序写法（入栈顺序为右左中） vector<int> preorder(TreeNode * root){ vector<int>res; stack<TreeNode*> st if(root!=nullptr) st.push(root); while(!call.empt
树的层序遍历：
weixin_30298497的博客
08-28 75
层次遍历：即每一层从左向右输出 元素需要储存有先进先出的特性，所以选用队列存储。 队列的定义： #defineMAX1000 typedefstructseqqueue{ bintreedata[MAX]; intfront; intrear; }seqqueue; voiden...
迭代（层序遍历，BFS）递归（深度优先遍历，DFS）Java
最新发布
07-07
<think>我们首先需要明确二叉树的层序遍历（BFS）和深度优先遍历（DFS）的迭代与递归方法。 根据引用[2]，二叉树的遍历分为深度优先（DFS）和广度优先（BFS）。其中深度优先包括前序、中序、后序，广度优先即层序遍历。 用户要求实现： 1. 层序遍历（BFS）的迭代和递归方法 2. 深度优先遍历（DFS）的迭代和递归方法（这里DFS通常指前序遍历，但有时也包含中序和后序，但用户没有特别指明，我们通常以DFS指前序遍历，但为了全面，我们可以实现前序遍历的迭代和递归，同时也可以提及其他DFS遍历） 但是注意，用户特别要求的是层序遍历（BFS）和深度优先遍历（DFS）的迭代与递归方法。其中： - 层序遍历（BFS）通常使用迭代（队列）实现，递归实现相对少见，但也可以实现。 - 深度优先遍历（DFS）通常包括前序、中序、后序，这里用户没有具体说明，但根据引用[3]和[4]，DFS通常指前序遍历（根左右），而中序和后序也是DFS。 为了满足用户要求，我们将分别实现： 1. 层序遍历（BFS）： 迭代方法：使用队列 递归方法：需要记录层数，然后递归每一层，将同一层的节点值收集起来（这种方法效率不高，但可以展示递归思路） 2. 深度优先遍历（DFS）： 这里我们以DFS（前序遍历）为例，同时我们也可以实现中序和后序的迭代和递归方法，但用户要求的是DFS，通常DFS指前序遍历，所以我们将重点放在前序遍历上，但为了完整性，我们可以简单提及中序和后序。 但是，用户要求的是“深度优先遍历（DFS）”，而DFS通常包括前序、中序、后序，但用户没有具体说明。根据引用[3]和[4]，DFS的结果是前序遍历（根左右）的顺序。因此，我们主要实现前序遍历的迭代和递归。 然而，注意引用[4]中给出了DFS的迭代实现（使用栈），并且是前序遍历（根左右）的顺序。 因此，我们计划如下： 一、层序遍历（BFS） 1. 迭代方法：使用队列 2. 递归方法：通过递归函数，传入当前层节点列表，处理当前层节点，然后收集下一层节点，递归处理下一层。 二、深度优先遍历（DFS）【以前序遍历为例】 1. 递归方法：先访问根节点，然后递归左子树，再递归右子树。 2. 迭代方法：使用栈，先将根节点入栈，然后循环中出栈一个节点，访问它，然后先右子节点入栈，再左子节点入栈（这样出栈顺序才是根左右）。 同时，我们也可以简要提供中序和后序的递归和迭代方法，但用户要求的是DFS，而DFS通常指前序遍历，所以我们将前序遍历作为DFS的代表。 但是，用户的问题中同时要求了DFS的迭代和递归，所以我们只实现前序遍历的迭代和递归。 另外，用户要求使用Java实现。 下面我们将分别实现： 1. 层序遍历（BFS）的迭代和递归 2. 深度优先遍历（DFS）的前序遍历的迭代和递归 注意：中序遍历和后序遍历的迭代实现相对复杂，如果用户没有特别要求，我们暂时不实现。但为了知识的完整性，我们可以简要说明DFS包括前序、中序、后序，并给出递归的统一写法，而迭代写法可以另外说明。 然而，用户要求的是“深度优先遍历（DFS）”，而DFS通常指前序遍历（如引用[3]和[4]所示），所以我们重点实现前序遍历。 实现如下： 首先，定义二叉树节点类： ```java 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; } } ``` 一、层序遍历（BFS） 1. 迭代方法（使用队列）： ```java public List<Integer> bfsIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); while (!queue.isEmpty()) { TreeNode node = queue.poll(); result.add(node.val); if (node.left != null) queue.offer(node.left); if (node.right != null) queue.offer(node.right); } return result; } ``` 2. 递归方法（需要辅助函数，按层处理）： 递归方法不是按节点递归，而是按层递归。我们设计一个递归函数，传入当前层的节点列表，然后： - 如果当前层节点列表为空，则返回 - 否则，将当前层节点的值加入结果，然后收集下一层的所有节点，递归处理下一层 但是这样得到的结果是一个列表，而不是按层分组的。用户要求的是层序遍历，即按层从左到右的顺序输出节点值，但不要求分层（除非用户要求分层输出）。通常层序遍历输出一个一维列表，所以我们可以这样： ```java public List<Integer> bfsRecursive(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); bfsRecursiveHelper(queue, result); return result; } private void bfsRecursiveHelper(Queue<TreeNode> queue, List<Integer> result) { if (queue.isEmpty()) return; int size = queue.size(); for (int i = 0; i < size; i++) { TreeNode node = queue.poll(); result.add(node.val); if (node.left != null) queue.offer(node.left); if (node.right != null) queue.offer(node.right); } bfsRecursiveHelper(queue, result); } ``` 但是，这种方法虽然用了递归，但内部还是使用了队列，并且循环处理当前层。这实际上是递归和迭代的混合。还有一种递归方法是不使用队列，而是通过记录当前层节点，然后递归处理下一层节点（下一层节点由当前层节点的左右子节点组成）: ```java public List<Integer> bfsRecursive2(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; List<TreeNode> currentLevel = new ArrayList<>(); currentLevel.add(root); bfsRecursiveHelper2(currentLevel, result); return result; } private void bfsRecursiveHelper2(List<TreeNode> currentLevel, List<Integer> result) { if (currentLevel.isEmpty()) return; List<TreeNode> nextLevel = new ArrayList<>(); for (TreeNode node : currentLevel) { result.add(node.val); if (node.left != null) nextLevel.add(node.left); if (node.right != null) nextLevel.add(node.right); } bfsRecursiveHelper2(nextLevel, result); } ``` 二、深度优先遍历（DFS）【前序遍历】 1. 递归方法： ```java public List<Integer> dfsPreorderRecursive(TreeNode root) { List<Integer> result = new ArrayList<>(); dfsPreorderRecursiveHelper(root, result); return result; } private void dfsPreorderRecursiveHelper(TreeNode node, List<Integer> result) { if (node == null) return; result.add(node.val); // 访问根节点 dfsPreorderRecursiveHelper(node.left, result); // 递归左子树 dfsPreorderRecursiveHelper(node.right, result); // 递归右子树 } ``` 2. 迭代方法（使用栈）： ```java public List<Integer> dfsPreorderIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Stack<TreeNode> stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { TreeNode node = stack.pop(); result.add(node.val); // 注意：先右后左，这样左子树先出栈 if (node.right != null) stack.push(node.right); if (node.left != null) stack.push(node.left); } return result; } ``` 另外，中序和后序遍历的递归方法与前序遍历类似，只是访问根节点的时机不同。 中序遍历递归： ```java private void dfsInorderRecursiveHelper(TreeNode node, List<Integer> result) { if (node == null) return; dfsInorderRecursiveHelper(node.left, result); // 递归左子树 result.add(node.val); // 访问根节点 dfsInorderRecursiveHelper(node.right, result); // 递归右子树 } ``` 后序遍历递归： ```java private void dfsPostorderRecursiveHelper(TreeNode node, List<Integer> result) { if (node == null) return; dfsPostorderRecursiveHelper(node.left, result); // 递归左子树 dfsPostorderRecursiveHelper(node.right, result); // 递归右子树 result.add(node.val); // 访问根节点 } ``` 中序遍历迭代（使用栈）： ```java public List<Integer> dfsInorderIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); Stack<TreeNode> stack = new Stack<>(); TreeNode curr = root; while (curr != null || !stack.isEmpty()) { while (curr != null) { stack.push(curr); curr = curr.left; } curr = stack.pop(); result.add(curr.val); curr = curr.right; } return result; } ``` 后序遍历迭代（使用栈）： ```java public List<Integer> dfsPostorderIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Stack<TreeNode> stack = new Stack<>(); stack.push(root); TreeNode prev = null; while (!stack.isEmpty()) { TreeNode curr = stack.peek(); // 如果当前节点没有子节点，或者子节点已经被访问过，则访问当前节点 if ((curr.left == null && curr.right == null) || (prev != null && (prev == curr.right || (prev == curr.left && curr.right == null)))) { result.add(curr.val); stack.pop(); prev = curr; } else { // 先右后左，这样左子树先处理 if (curr.right != null) stack.push(curr.right); if (curr.left != null) stack.push(curr.left); } } return result; } ``` 但是，用户要求的是DFS（深度优先遍历）的迭代和递归，而DFS通常指前序遍历。因此，我们主要提供前序遍历的迭代和递归。 总结代码： 我们将提供以下方法： 1. bfsIterative: 层序遍历的迭代实现 2. bfsRecursive: 层序遍历的递归实现（按层递归） 3. dfsPreorderRecursive: DFS前序遍历递归 4. dfsPreorderIterative: DFS前序遍历迭代 同时，为了完整性，我们可以简要说明中序和后序的遍历方法，但代码中不展开（除非用户要求）。 最后，生成相关问题： 1. 层序遍历和深度优先遍历的时间复杂度分别是多少？ 2. 深度优先遍历的中序和后序遍历如何用迭代方法实现？ 3. 层序遍历的递归方法为什么效率不如迭代方法？ 4. 如何实现二叉树的深度优先遍历（DFS）的分层输出？ 注意：引用[1][2][3][4]提供了二叉树遍历的基本概念和实现方法，我们在回答中参考了这些引用。 下面按照用户要求，将回答组织成结构清晰的形式。</think>### 二叉树遍历的 Java 实现（迭代与递归） #### 一、深度优先遍历（DFS） 深度优先遍历按照访问根节点的顺序分为三种：**前序遍历（根左右）、中序遍历（左根右）、后序遍历（左右根）**。 ##### 1. DFS 递归实现 ```java // 前序遍历（递归） public void dfsPreOrder(TreeNode root, List<Integer> result) { if (root == null) return; result.add(root.val); // 访问根节点 dfsPreOrder(root.left, result); // 遍历左子树 dfsPreOrder(root.right, result); // 遍历右子树 } // 中序遍历（递归） public void dfsInOrder(TreeNode root, List<Integer> result) { if (root == null) return; dfsInOrder(root.left, result); // 遍历左子树 result.add(root.val); // 访问根节点 dfsInOrder(root.right, result); // 遍历右子树 } // 后序遍历（递归） public void dfsPostOrder(TreeNode root, List<Integer> result) { if (root == null) return; dfsPostOrder(root.left, result); // 遍历左子树 dfsPostOrder(root.right, result); // 遍历右子树 result.add(root.val); // 访问根节点 } ``` ##### 2. DFS 迭代实现（使用栈） ```java // 前序遍历（迭代） public List<Integer> dfsPreOrderIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Stack<TreeNode> stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { TreeNode node = stack.pop(); result.add(node.val); // 访问根节点 if (node.right != null) stack.push(node.right); // 右子节点先入栈 if (node.left != null) stack.push(node.left); // 左子节点后入栈 } return result; } // 中序遍历（迭代） public List<Integer> dfsInOrderIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); Stack<TreeNode> stack = new Stack<>(); TreeNode curr = root; while (curr != null || !stack.isEmpty()) { while (curr != null) { stack.push(curr); // 左子树入栈 curr = curr.left; } curr = stack.pop(); result.add(curr.val); // 访问根节点 curr = curr.right; // 处理右子树 } return result; } // 后序遍历（迭代） public List<Integer> dfsPostOrderIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Stack<TreeNode> stack = new Stack<>(); stack.push(root); while (!stack.isEmpty()) { TreeNode node = stack.pop(); result.add(0, node.val); // 结果倒序插入（根→右→左） if (node.left != null) stack.push(node.left); if (node.right != null) stack.push(node.right); } return result; } ``` #### 二、层序遍历（BFS） 层序遍历按层级从上到下、从左到右访问节点，属于广度优先遍历。 ##### 1. BFS 迭代实现（使用队列） ```java public List<Integer> bfsIterative(TreeNode root) { List<Integer> result = new ArrayList<>(); if (root == null) return result; Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); while (!queue.isEmpty()) { TreeNode node = queue.poll(); result.add(node.val); // 访问当前节点 if (node.left != null) queue.offer(node.left); if (node.right != null) queue.offer(node.right); } return result; } ``` ##### 2. BFS 递归实现 ```java public List<List<Integer>> bfsRecursive(TreeNode root) { List<List<Integer>> result = new ArrayList<>(); bfsHelper(Collections.singletonList(root), result); return result; } private void bfsHelper(List<TreeNode> levelNodes, List<List<Integer>> result) { if (levelNodes.isEmpty()) return; List<Integer> levelValues = new ArrayList<>(); List<TreeNode> nextLevel = new ArrayList<>(); for (TreeNode node : levelNodes) { if (node == null) continue; levelValues.add(node.val); // 记录当前层节点值 if (node.left != null) nextLevel.add(node.left); if (node.right != null) nextLevel.add(node.right); } if (!levelValues.isEmpty()) result.add(levelValues); bfsHelper(nextLevel, result); // 递归处理下一层 } ``` ### 关键点说明 1. **DFS 核心**： - 递归：通过函数调用栈隐式实现回溯 - 迭代：显式使用栈模拟递归过程 - 时间复杂度：$O(n)$，空间复杂度：$O(h)$（$h$ 为树高） 2. **BFS 核心**： - 迭代：队列保证先进先出（FIFO）特性 - 递归：按层传递节点列表 - 时间复杂度：$O(n)$，空间复杂度：$O(n)$（最宽层节点数） 3. **选择建议**： - DFS 适合路径查找、回溯问题 - BFS 适合最短路径、层级分析 - 递归代码简洁但可能栈溢出，迭代更易控制资源[^1][^2][^3][^4] ### 相关问题 1. DFS 和 BFS 在空间复杂度上有何本质区别？ 2. 如何修改 DFS 迭代代码实现**倒序后序遍历**（左→右→根）？ 3. 递归实现的 BFS 能否优化空间复杂度？ 4. 在二叉树中查找特定节点时，DFS 和 BFS 哪种方法更高效？ 5. 如何实现 **N叉树** 的深度优先和广度优先遍历？[^3]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值