[二叉树的分层遍历] 倒序的树

本文介绍了一种二叉树的遍历方法——倒序分层遍历,并提供了一个具体的实现示例。该方法通过使用队列来保存每一层的节点,再将这些节点压入栈中,最后从栈中依次弹出节点并打印,从而实现了按倒序分层的方式遍历二叉树。

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

比如下面一棵树

    A

  B       C

D       E  F

按照DEFBCA的顺序输出,即倒序分层并按照顺序输出。

答,其实比较简单。我想到的办法是加一个栈,记录每一层的内容,最后输出。可能比较笨,如果有更好的办法,请告诉我。

 

#include <iostream>

#include <stack>

#include <queue>

 

struct TreeNode

{

    char data;

    TreeNode* leftChd;

    TreeNode* rightChd;

};

 

std::stack<TreeNode*> nodeStack;

std::queue<TreeNode*> nodeQueue;

 

void printTree(TreeNode* node)

{

    nodeQueue.push(node);

    while (nodeQueue.size() != 0) {

        TreeNode *tmp = nodeQueue.front();

        if(tmp->rightChd != NULL)

            nodeQueue.push(tmp->rightChd);

        if(tmp->leftChd != NULL)

            nodeQueue.push(tmp->leftChd);

        nodeStack.push(tmp);

        nodeQueue.pop();

    }

}

 

void printStack(std::stack<TreeNode*> test)

{

    while(test.size() != 0)

    {

        std::cout << test.top()->data << std::endl;

        test.pop();

    }

}

 

int main(int argc, const char * argv[])

{

    TreeNode *a = new TreeNode;

    a->TreeNode::data = 'A';

    TreeNode *b = new TreeNode;

    b->TreeNode::data = 'B';

    TreeNode *c = new TreeNode;

    c->TreeNode::data = 'C';

    TreeNode *d = new TreeNode;

    d->TreeNode::data = 'D';

    TreeNode *e = new TreeNode;

    e->TreeNode::data = 'E';

    TreeNode *f = new TreeNode;

    f->TreeNode::data = 'F';

    a->leftChd = b;

    a->rightChd = c;

    b->leftChd = d;

    c->leftChd = e;

    c->rightChd =f;

    std::cout << "Hello, MAC!\n";

    printTree(a);

    printStack(nodeStack);

    return 0;

}

 

我写的不是很好,希望跟各位多多交流。

转载于:https://www.cnblogs.com/xie-mx/p/3930325.html

<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]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值