二叉树的深度优先遍历和广度优先遍历

原创 已于 2023-03-07 10:09:57 修改 · 1.3w 阅读 · 41 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #二叉树 #深度优先遍历 #广度优先遍历

于 2016-10-07 20:18:15 首次发布
本文介绍了二叉树的深度优先遍历与广度优先遍历的方法，包括递归与非递归实现，并通过实例展示了先序、中序、后序及广度优先遍历的过程。

1. 分析

二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下：

  • 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。
  • 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。
  • 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。

广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。

2. 举例说明

对下图所示的二叉排序树进行遍历，要求使用先序遍历（递归、非递归）、中序遍历（递归、非递归）、后序遍历（递归、非递归）和广度优先遍历。

2.1 参考代码

package BinaryTreeTraverseTest;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉树的深度优先遍历和广度优先遍历
 * @author Fantasy
 * @version 1.0 2016/10/05 - 2016/10/07
 */
public class BinaryTreeTraverseTest {
    public static void main(String[] args) {
		
	BinarySortTree<Integer> tree = new BinarySortTree<Integer>();
        
        tree.insertNode(35);
        tree.insertNode(20);
        tree.insertNode(15);
        tree.insertNode(16);
        tree.insertNode(29);
        tree.insertNode(28);
        tree.insertNode(30);
        tree.insertNode(40);
        tree.insertNode(50);
       	tree.insertNode(45);
       	tree.insertNode(55);
        
       	System.out.print("先序遍历（递归）：");
       	tree.preOrderTraverse(tree.getRoot());
       	System.out.println();
       	System.out.print("中序遍历（递归）：");
       	tree.inOrderTraverse(tree.getRoot());
      	System.out.println();
       	System.out.print("后序遍历（递归）：");
       	tree.postOrderTraverse(tree.getRoot());
       	System.out.println();
        
       	System.out.print("先序遍历（非递归）：");
       	tree.preOrderTraverseNoRecursion(tree.getRoot());
       	System.out.println();
       	System.out.print("中序遍历（非递归）：");
       	tree.inOrderTraverseNoRecursion(tree.getRoot());
       	System.out.println();
       	System.out.print("后序遍历（非递归）：");
       	tree.postOrderTraverseNoRecursion(tree.getRoot());
       	System.out.println();
        
       	System.out.print("广度优先遍历：");
       	tree.breadthFirstTraverse(tree.getRoot());
    }
}

/**
 * 结点
 */
class Node<E extends Comparable<E>> {
	
    E value;
    Node<E> left;
    Node<E> right;
    
    Node(E value) {
        this.value = value;
        left = null;
        right = null;
    }
    
}

/**
 * 使用一个先序序列构建一棵二叉排序树（又称二叉查找树）
 */
class BinarySortTree<E extends Comparable<E>> {
	
    private Node<E> root;
    
    BinarySortTree() {
        root = null;
    }
    
    public void insertNode(E value) {	
        if (root == null) {
            root = new Node<E>(value);
            return;
        }    
        Node<E> currentNode = root;
        while (true) {
            if (value.compareTo(currentNode.value) > 0) {
            	if (currentNode.right == null) {
                    currentNode.right = new Node<E>(value);
                    break;
                }
                currentNode = currentNode.right;
            } else {
                if (currentNode.left == null) {
                    currentNode.left = new Node<E>(value);
                    break;
                }
                currentNode = currentNode.left;
            }
        }
    }
    
    public Node<E> getRoot(){
        return root;
    }

    /**
     * 先序遍历二叉树（递归）
     * @param node
     */
    public void preOrderTraverse(Node<E> node) {
    	System.out.print(node.value + " ");
    	if (node.left != null)
    		preOrderTraverse(node.left);
    	if (node.right != null)
    		preOrderTraverse(node.right);
    }
    
    /**
     * 中序遍历二叉树（递归）
     * @param node
     */
    public void inOrderTraverse(Node<E> node) {
    	if (node.left != null)
    		inOrderTraverse(node.left);
    	System.out.print(node.value + " ");
    	if (node.right != null)
    		inOrderTraverse(node.right);
    }
    
    /**
     * 后序遍历二叉树（递归）
     * @param node
     */
    public void postOrderTraverse(Node<E> node) {
    	if (node.left != null)
    		postOrderTraverse(node.left);
    	if (node.right != null)
    		postOrderTraverse(node.right);
    	System.out.print(node.value + " ");
    }
    
    /**
     * 先序遍历二叉树（非递归）
     * @param root
     */
    public void preOrderTraverseNoRecursion(Node<E> root) {
    	LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    	Node<E> currentNode = null;
    	stack.push(root);
    	while (!stack.isEmpty()) {
    		currentNode = stack.pop();
    		System.out.print(currentNode.value + " ");
    		if (currentNode.right != null)
    			stack.push(currentNode.right);
    		if (currentNode.left != null)
    			stack.push(currentNode.left);
    	}
    }
    
    /**
     * 中序遍历二叉树（非递归）
     * @param root
     */
    public void inOrderTraverseNoRecursion(Node<E> root) {
    	LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    	Node<E> currentNode = root;
    	while (currentNode != null || !stack.isEmpty()) {
    		// 一直循环到二叉排序树最左端的叶子结点（currentNode是null）
    		while (currentNode != null) {
    			stack.push(currentNode);
    			currentNode = currentNode.left;
    		}
			currentNode = stack.pop();
			System.out.print(currentNode.value + " ");
			currentNode = currentNode.right;
    	}	
    }
    
    /**
     * 后序遍历二叉树（非递归）
     * @param root
     */
    public void postOrderTraverseNoRecursion(Node<E> root) {
    	LinkedList<Node<E>> stack = new LinkedList<Node<E>>();
    	Node<E> currentNode = root;
    	Node<E> rightNode = null;
    	while (currentNode != null || !stack.isEmpty()) {
    		// 一直循环到二叉排序树最左端的叶子结点（currentNode是null）
    		while (currentNode != null) {
    			stack.push(currentNode);
    			currentNode = currentNode.left;
    		}
    		currentNode = stack.pop();
    		// 当前结点没有右结点或上一个结点（已经输出的结点）是当前结点的右结点，则输出当前结点
    		while (currentNode.right == null || currentNode.right == rightNode) {
    			System.out.print(currentNode.value + " ");
    			rightNode = currentNode;
    			if (stack.isEmpty()) {
    				return; //root以输出，则遍历结束
    			}
    			currentNode = stack.pop();
    		}
    		stack.push(currentNode); //还有右结点没有遍历
    		currentNode = currentNode.right;
    	}
    }
    
    /**
     * 广度优先遍历二叉树，又称层次遍历二叉树
     * @param node
     */
    public void breadthFirstTraverse(Node<E> root) {
    	Queue<Node<E>> queue = new LinkedList<Node<E>>();
    	Node<E> currentNode = null;
    	queue.offer(root);
    	while (!queue.isEmpty()) {
    		currentNode = queue.poll();
    		System.out.print(currentNode.value + " ");
    		if (currentNode.left != null)
    			queue.offer(currentNode.left);
    		if (currentNode.right != null)
    			queue.offer(currentNode.right);
    	}
    }
    
}

2.2 输出结果

先序遍历（递归）：35 20 15 16 29 28 30 40 50 45 55 
中序遍历（递归）：15 16 20 28 29 30 35 40 45 50 55 
后序遍历（递归）：16 15 28 30 29 20 45 55 50 40 35 
先序遍历（非递归）：35 20 15 16 29 28 30 40 50 45 55 
中序遍历（非递归）：15 16 20 28 29 30 35 40 45 50 55 
后序遍历（非递归）：16 15 28 30 29 20 45 55 50 40 35 
广度优先遍历：35 20 40 15 29 50 16 28 30 45 55 

二叉树深度优先遍历和广度优先遍历
jacke121的专栏
10-16 3073
二叉树深度优先遍历和广度优先遍历
二叉树的深度优先遍历
zhonghua18517的专栏
06-03 1万+
二叉树的深度优先遍历和先序遍历结果一样的。 思想是采用栈，
二叉树广度和深度优先遍历
04-20
二叉树广度和深度优先遍历，通过递归算法实现二叉树的建立，利用递归算法实现深度优先遍历，使用队列实现广度优先遍历
数据结构——二十九、图的广度优先遍历(BFS)(王道408)
最新发布
2301_80201235的博客
10-23 1258
本文探讨了图的广度优先遍历(BFS)算法。首先通过与树的广度优先遍历对比，指出两者在横向搜索节点方面的相似性，以及图遍历中可能遇到的环路问题。接着详细介绍了BFS的实现思路：使用访问标记数组、辅助队列和两个基本操作（FirstNeighbor和NextNeighbor）来获取相邻节点。代码实现部分展示了从初始顶点出发，依次访问并标记相邻顶点并入队的过程。通过示例图解说明了算法执行时队列和访问标记的动态变化，帮助理解BFS如何逐层探索图中的节点。文章系统性地阐述了BFS的核心概念和实现方法。
二叉树(一)：深度优先遍历与广度优先遍历
Mike_honor的博客
07-17 3272
二叉树是一种非常高效的数据结构，树结构可以高效地查找和搜索语义，比如近邻算法中就用到了树来存储训练数据，大大提高了近邻搜索的效率，又比如电脑的文件管理器，都采用了树结构，通过树查找会变得十分快捷。总之，二叉树这种数据结构的应用非常广泛，能够大大提高搜索效率，本文将全面讲解二叉树结构以及二叉树的相关算法，相信会对大家数据结构与算法的学习产生很大的帮助。...............
Java实现二叉树的深度优先遍历和广度优先遍历算法示例
08-27
本文详细介绍了Java实现二叉树的深度优先遍历和广度优先遍历算法，通过实例代码展示了深度优先遍历和广度优先遍历的实现过程，并对二叉树的定义、深度优先遍历与广度优先遍历算法原理与相关操作实现技巧进行了详细...
二叉树的遍历——深度优先遍历与广度优先遍历
m0_74217734的博客
10-29 527
二叉树遍历是按照一定的次序访问二叉树中的所有结点，并且每个结点仅被访问一次。一颗二叉树是由三个部分构成（根结点、左子树和右子树）构成，因此在遍历二叉树时也可以从任何部分开始遍历，所以有3！中遍历方法。但是我们约定在遍历二叉树时，先遍历左子树再遍历右子树，则对于非空二叉树，可以得到三种递归遍历方法，而这三种方法我们统称为深度优先遍历法。而广度遍历法则是以另一个角度来遍历二叉树，通过根结点来引出左右子树，最终实现遍历。
Python实现二叉树的深度优先遍历和广度优先遍历
HeiJack的博客
06-30 1095
二叉树的遍历分为深度优先遍历和广度优先遍历 。 深度优先遍历顾名思义是从树的一条分支走到底才进行回溯，深度优先遍历又分为前序遍历，中序遍历和后序遍历。 一棵二叉树由根结点、左子树和右子树三部分组成，若规定 D、L、R 分别代表遍历根结点、遍历左子树、遍历右子树。 DLR--前序遍历（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面） LDR--中序遍历（根在中，从左往右，一棵树的左子树永远在根前面，根永远在右子树前面） ...
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
js代码-二叉树广度优先遍历
07-16
本篇文章将深入探讨如何使用JS进行二叉树的广度优先遍历（BFS）。 **一、二叉树的基础概念** 二叉树的基本元素是节点，每个节点包含三个部分：数据、左指针和右指针。在JS中，我们可以创建一个Node类来表示二叉树...
二叉树的深度优先遍历与广度优先遍历
Hopefully Sky的博客
07-16 1416
public class BinaryTree<T extends Comparable<T>> { /** * 根结点 */ private TreeNode<T> root; /** * 是否通过前序及中序遍历来初始化 */ private boolean initByPreInOrder; public BinaryTree(boolean initByPreInOrder) {
二叉树的深度优先遍历 以及 广度优先遍历
weixin_45727472的博客
09-25 356
一、二叉树的深度优先遍历 实际上，二叉树的深度优先遍历和二叉树的前序遍历结果一致，如下： 1、题目地址 https://leetcode-cn.com/problems/binary-tree-preorder-traversal/ 2、具体代码 （1）递归法 /** * Definition for a binary tree node. * function TreeNode(val, left, right) { * this.val = (val===undefined ? 0 : v
二叉树遍历——深度优先遍历、广度优先遍历
热门推荐
雾幻的博客
10-23 3万+
二叉树遍历简介 深度优先遍历： 对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。 要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下： 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。 中序遍历：对任一子树，先遍历其左子树，然后访问根，...
二叉树遍历(深度优先+广度优先)
Dablelv 的博客专栏。
05-22 1万+
二叉树的遍历分为两类，一类是深度优先遍历，一类是广度优先遍历。
二叉树的深度优先和广度优先遍历
风之去向
09-14 9516
图的深度优先搜索法是树的先根遍历的推广，它的基本思想是：从图G的某个顶点v0出发，访问v0，然后选择一个与v0相邻且没被访问过的顶点vi访问，再从vi出发选择一个与vi相邻且未被访问的顶点vj进行访问，依次继续。如果当前被访问过的顶点的所有邻接顶点都已被访问，则退回到已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点w，从w出发按同样的方法向前遍历，直到图中所有顶点都被访问。图的广度优先
C语言中的二叉树深度优先遍历和广度优先遍历
10-20
<think>我们已经在之前的对话中讨论了二叉树深度优先遍历（DFS）和广度优先遍历（BFS）的原理和实现（包括Java和JavaScript）。现在用户询问C语言中的实现方法。我们将分别用C语言实现DFS（包括递归和非递归）和BFS。 注意：在C语言中，我们需要自己定义二叉树节点结构，并实现栈和队列（因为C标准库没有提供栈和队列容器）。为了简化，我们可以用数组模拟栈，用数组或链表实现队列。这里我们使用数组模拟栈和循环队列。 步骤： 1. 定义二叉树节点结构。 2. 实现深度优先遍历（DFS）： a. 递归实现：先序、中序、后序。 b. 非递归实现：使用栈（这里以先序遍历为例）。 3. 实现广度优先遍历（BFS）：使用队列。 注意：在非递归遍历中，要防止栈溢出（深度很大时）和队列溢出（广度很大时）。这里我们假设树不会太大。 我们首先定义二叉树节点： ```c typedef struct TreeNode { int data; // 节点数据 struct TreeNode* left; // 左子节点 struct TreeNode* right; // 右子节点 } TreeNode; ``` 深度优先遍历（DFS）递归实现： 先序遍历（根->左->右） ```c void preOrderRecursive(TreeNode* root) { if (root == NULL) return; printf("%d ", root->data); // 访问根节点 preOrderRecursive(root->left); preOrderRecursive(root->right); } ``` 中序遍历（左->根->右） ```c void inOrderRecursive(TreeNode* root) { if (root == NULL) return; inOrderRecursive(root->left); printf("%d ", root->data); inOrderRecursive(root->right); } ``` 后序遍历（左->右->根） ```c void postOrderRecursive(TreeNode* root) { if (root == NULL) return; postOrderRecursive(root->left); postOrderRecursive(root->right); printf("%d ", root->data); } ``` 深度优先遍历（DFS）非递归实现（先序遍历）： 使用栈（数组模拟栈） 步骤： 1. 创建一个栈，并将根节点入栈。 2. 当栈非空时： a. 弹出栈顶节点并访问。 b. 将其右子节点入栈（如果有）。 c. 将其左子节点入栈（如果有）。 注意：由于栈是后进先出，所以先右后左，保证左子树先被访问。 假设栈的最大容量为100（根据实际情况调整）。 ```c void preOrderNonRecursive(TreeNode* root) { if (root == NULL) return; // 定义栈 TreeNode* stack[100]; int top = -1; // 栈顶指针 stack[++top] = root; // 根节点入栈 while (top >= 0) { // 弹出栈顶 TreeNode* node = stack[top--]; printf("%d ", node->data); // 先右后左入栈 if (node->right != NULL) { stack[++top] = node->right; } if (node->left != NULL) { stack[++top] = node->left; } } } ``` 广度优先遍历（BFS）： 使用队列（这里使用数组模拟循环队列） 步骤： 1. 创建一个队列，将根节点入队。 2. 当队列非空时： a. 出队一个节点并访问。 b. 将其左子节点入队（如果有）。 c. 将其右子节点入队（如果有）。 注意：队列的容量也需要预先设定（这里设为100）。 ```c void bfs(TreeNode* root) { if (root == NULL) return; // 定义队列 TreeNode* queue[100]; int front = 0; // 队头指针 int rear = 0; // 队尾指针 queue[rear++] = root; // 根节点入队 while (front != rear) { // 出队 TreeNode* node = queue[front++]; // 循环队列，防止越界（这里假设不会满，因为节点个数不超过100） printf("%d ", node->data); // 左子节点入队 if (node->left != NULL) { queue[rear++] = node->left; // 如果rear达到数组末尾，可以考虑循环（这里简单处理，假设树不大） } // 右子节点入队 if (node->right != NULL) { queue[rear++] = node->right; } } } ``` 注意：上述队列实现是顺序队列，当队列满时（rear==100）会溢出。在实际应用中，应该使用循环队列或者动态扩容。这里为了简单，假设树节点不超过100。 总结： - DFS递归：简洁，但可能栈溢出（树很深时）。 - DFS非递归：显示使用栈，避免了递归的栈溢出问题（但我们的栈是固定大小的，仍然可能溢出，可以动态扩容栈）。 - BFS：使用队列按层遍历，适合求最短路径等问题。 引用说明： [1]中提到深度优先遍历有三种递归遍历方法（先序、中序、后序），并约定先遍历左子树再遍历右子树[^1]。 [2]中介绍了二叉树的四种遍历方法（前序、中序、后序和层次遍历）的C语言实现，包括递归和非递归[^2]。 相关问题： 1. 如何用非递归方法实现二叉树的中序遍历和后序遍历？ 2. 在广度优先遍历中，如何记录每个节点的层次？ 3. 深度优先遍历的非递归实现中，如何避免栈溢出问题？ 4. 如何在遍历二叉树时动态分配栈和队列的空间以避免固定大小的限制？ 注意：由于用户要求用中文回答，并且按照指定格式，我们在代码中已经使用了注释，并在总结部分使用中文。 </think>### C语言实现二叉树深度优先遍历与广度优先遍历 #### **一、二叉树节点定义** ```c typedef struct TreeNode { int data; // 节点数据 struct TreeNode* left; // 左子节点 struct TreeNode* right; // 右子节点 } TreeNode; ``` #### **二、深度优先遍历（DFS）实现** ##### 1. **递归实现** ```c // 先序遍历（根-左-右） void preOrder(TreeNode* root) { if (root == NULL) return; printf("%d ", root->data); // 访问根节点 preOrder(root->left); // 递归左子树 preOrder(root->right); // 递归右子树 } // 中序遍历（左-根-右） void inOrder(TreeNode* root) { if (root == NULL) return; inOrder(root->left); printf("%d ", root->data); inOrder(root->right); } // 后序遍历（左-右-根） void postOrder(TreeNode* root) { if (root == NULL) return; postOrder(root->left); postOrder(root->right); printf("%d ", root->data); } ``` > **特点**：简洁易实现，空间复杂度$O(h)$（$h$为树高），但递归深度过大时可能栈溢出[^1]。 --- ##### 2. **非递归实现（显式栈）** ```c #include <stdlib.h> #define MAX_SIZE 100 // 栈最大容量 // 先序遍历非递归 void preOrderNonRecursive(TreeNode* root) { if (root == NULL) return; TreeNode* stack[MAX_SIZE]; // 栈初始化 int top = -1; // 栈顶指针 stack[++top] = root; // 根节点入栈 while (top >= 0) { TreeNode* node = stack[top--]; // 弹出栈顶 printf("%d ", node->data); // 右子节点先入栈（后出） if (node->right != NULL) stack[++top] = node->right; // 左子节点后入栈（先出） if (node->left != NULL) stack[++top] = node->left; } } ``` > **关键**：利用栈的LIFO特性，右子节点先入栈保证左子树优先访问[^2]。 --- #### **三、广度优先遍历（BFS）实现** ```c #include <stdlib.h> #define MAX_QUEUE 100 void bfs(TreeNode* root) { if (root == NULL) return; TreeNode* queue[MAX_QUEUE]; // 队列初始化 int front = 0, rear = 0; // 队列头尾指针 queue[rear++] = root; // 根节点入队 while (front < rear) { TreeNode* node = queue[front++]; // 出队 printf("%d ", node->data); // 左子节点入队 if (node->left != NULL) queue[rear++] = node->left; // 右子节点入队 if (node->right != NULL) queue[rear++] = node->right; } } ``` > **核心**： > - 使用队列的FIFO特性确保层级顺序[^1] > - 空间复杂度$O(w)$（$w$为树最大宽度） --- #### **四、性能对比与应用场景** | **指标** | **DFS递归** | **DFS非递归** | **BFS** | |----------------|----------------|------------------|------------------| | **空间开销** | $O(h)$ | $O(h)$ | $O(w)$ | | **栈溢出风险** | 高（深树） | 可控（固定栈） | 无 | | **适用场景** | 路径回溯、搜索 | 深树遍历 | 层级分析、最短路径 | > **典型应用**： > - DFS：查找所有根到叶子的路径、表达式树求值 > - BFS：二叉树层序遍历、最小深度计算 --- ### 相关问题 1. 如何用非递归实现二叉树的中序遍历和后序遍历？ 2. 在广度优先遍历中，如何记录每个节点所在的层级？ 3. 深度优先遍历的非递归实现为何需要显式栈？与递归栈有何区别？ 4. 如何优化BFS的空间复杂度以处理超宽二叉树？ [^1]: 二叉树的遍历——深度优先遍历与广度优先遍历 [^2]: C语言实现二叉树四种遍历方法
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值