【补充】二叉树的遍历丨代码详解

已于 2024-06-22 11:24:53 修改
阅读量615 收藏 7
点赞数 11
分类专栏： 数据结构 文章标签： 算法 数据结构
于 2024-05-18 10:53:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74315738/article/details/139021345
版权

一、3种递归遍历方法

二叉树由3个基本单元组成：根结点、左子树和右子树。因此，若能依次遍历这三部分，便是遍历了整个二叉树。

假如以L、D、R分别表示遍历二叉树的方案，若限定先左后右则只有3中情况：

（1）先序遍历法：
先访问根结点，再先序遍历左子树，再是右子树。
如右图的二叉树，先序遍历法则输出：
1 2 5 6 3 4 7 8 9 10
（2）中序遍历法：
左子树 -> 根结点 -> 右子树
5 6 2 3 8 9 10 7 4 1
（3）后序遍历法：
左子树 -> 右子树 ->根结点
6 5 10 9 8 7 4 3 2 1 

递归算法代码实现：

先序遍历法的代码如上，中序以及后序遍历法的代码类似，只需要把递归函数的位置调换即可。

void preOrderPrint(BiTreeNode* root)
{
    if (root == NULL)
    {
        return;
    }
    printf("%d  ", root->data);
    preOrderPrint(root->leftChild);
    preOrderPrint(root->rightBrother);
}
void printBiTree(BiTree bitree)
{
    BiTreeNode* root = &bitree.btns[0];
    preOrderPrint(root);
}

注：考试不会考简单的递归算法，更多的是写出如何用堆栈的方法（非递归的方法）来实现。

仍然以先序遍历法为例：

void PreOrderTraversal_stack(BiTreeNode* root)
{
    if (root == NULL)
    {
        return;
    }

    Stack stack;
    initStack(&stack);
    BiTreeNode* current = root;

    while (current != NULL || !isEmpty(&stack))
    {
        while (current != NULL)
        {
            printf("%d ", current->data);
            push(&stack, current);
            current = current->leftChild;
        }
        if (!isEmpty(&stack))
        {
            current = pop(&stack);
            current = current->rightBrother;
        }
    }
}

其中，堆栈的定义和基本操作如下：

typedef struct StackNode
{
    BiTreeNode* node;
    struct StackNode* next;
} StackNode;
typedef struct Stack
{
    StackNode* top;
} Stack;

//1、堆栈的初始化
void initStack(Stack* stack)
{
    stack->top = NULL;
}
//2、判断堆栈是否为空
bool isEmpty(Stack* stack)
{
    return stack->top == NULL;
}
//3、入栈
void push(Stack* stack, BiTreeNode* node)
{
    StackNode* newNode = (StackNode*)malloc(sizeof(StackNode));
    newNode->node = node;
    newNode->next = stack->top;
    stack->top = newNode;
}
//4、出栈
BiTreeNode* pop(Stack* stack)
{
    if (stack->top == NULL)
    {
        return NULL;
    }
    BiTreeNode* node = stack->top->node;
    StackNode* temp = stack->top;
    stack->top = stack->top->next;
    free(temp);
    return node;
}

二、层次遍历法

1. 定义一个队列，并把二叉树的根节点放入队列中。
2. 循环遍历队列，直到队列为空。
3. 在每一轮循环中，首先从队列中取出一个节点，并打印节点的值。
4. 如果该节点有左子树，则把左子树放入队列中。
5. 如果该节点有右子树，则把右子树放入队列中。
6. 重复步骤3-5，直到队列为空。 

void levelOrderTraversal(BiTreeNode* root)
{
    if (root == NULL)
    {
        return;
    }

    QueueNode* queue = NULL;
    enqueue(&queue, root);

    while (queue != NULL)
    {
        BiTreeNode* node = dequeue(&queue);
        printf("%d ", node->data);

        if (node->leftChild != NULL)
        {
            enqueue(&queue, node->leftChild);
        }

        if (node->rightBrother != NULL)
        {
            enqueue(&queue, node->rightBrother);
        }
    }
}

 其中enqueue是入队操作，dequeue是出队操作。二者定义如下：

// 入队操作
void enqueue(QueueNode** queue, BiTreeNode* node)
{
    QueueNode* new_node = (QueueNode*)malloc(sizeof(QueueNode));
    new_node->btn = node;
    new_node->next = NULL;

    if (*queue == NULL)
    {
        *queue = new_node;
    }
    else
    {
        QueueNode* curr = *queue;
        while (curr->next != NULL)
        {
            curr = curr->next;
        }
        curr->next = new_node;
    }
}

// 出队操作
BiTreeNode* dequeue(QueueNode** queue)
{
    if (*queue == NULL)
    {
        return NULL;
    }

    BiTreeNode* node = (*queue)->btn;
    QueueNode* temp = *queue;
    *queue = (*queue)->next;
    free(temp);
    return node;
}

 可运行完整代码：下面这段代码利用parent数组创建一棵普通树，将树转换为孩子兄弟法表示的二叉树，并用层次遍历法打印这棵二叉树。

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 20

#define _CRT_SECURE_NO_WARNINGS

//定义树结构
typedef struct TreeNode
{
    int data;
    struct TreeNode* parent;
} TreeNode;
typedef struct Tree
{
    TreeNode tns[MAX_SIZE];
    int r, n;
} Tree;
Tree tree;
Tree tree2;

//定义二叉树结构
typedef struct BiTreeNode
{
    int data;
    struct BiTreeNode* leftChild;
    struct BiTreeNode* rightBrother;
} BiTreeNode;
typedef struct BiTree
{
    BiTreeNode btns[MAX_SIZE];
    int r, n;
} BiTree;
BiTree bitree;

//定义队列结构及其操作
typedef struct QueueNode
{
    BiTreeNode* btn;
    struct QueueNode* next;
} QueueNode;
// 入队操作
void enqueue(QueueNode** queue, BiTreeNode* node);
// 出队操作
BiTreeNode* dequeue(QueueNode** queue);

Tree createTree(int parent[]);//用parent数组创建树
void findChild(BiTreeNode* root, Tree tree);//树转二叉树的辅助函数
BiTree treeToBiTree(Tree tree);//将树转换为二叉树
void levelOrderTraversal(BiTreeNode* root);// 层次顺序遍历二叉树

int main()
{
    //1、传入parent数组
    int parent[10] = { -1, 0, 0, 0, 1, 1, 3, 6, 6, 6 };
    //2、创建树
    Tree tree = createTree(parent);
    //3、将树转换为二叉树
    BiTree tree1 = treeToBiTree(tree);
    //4、层次遍历法遍历二叉树
    levelOrderTraversal(&tree1.btns[0]);

    return 0;
}

void enqueue(QueueNode** queue, BiTreeNode* node)
{
    QueueNode* new_node = (QueueNode*)malloc(sizeof(QueueNode));
    new_node->btn = node;
    new_node->next = NULL;

    if (*queue == NULL)
    {
        *queue = new_node;
    }
    else
    {
        QueueNode* curr = *queue;
        while (curr->next != NULL)
        {
            curr = curr->next;
        }
        curr->next = new_node;
    }
}

BiTreeNode* dequeue(QueueNode** queue)
{
    if (*queue == NULL)
    {
        return NULL;
    }

    BiTreeNode* node = (*queue)->btn;
    QueueNode* temp = *queue;
    *queue = (*queue)->next;
    free(temp);
    return node;
}

Tree createTree(int parent[])
{
    tree.r = 0;
    tree.n = 0;
    while (tree.n < 10)
    {
        tree.tns[tree.n].data = tree.n + 1;
        tree.tns[tree.n].parent = NULL;

        if (parent[tree.n] != -1)
        {
            tree.tns[tree.n].parent = &tree.tns[parent[tree.n]];
        }
        tree.n++;
    }
    return tree;
}
void findChild(BiTreeNode* root, Tree tree)
{
    BiTreeNode* currentChild = NULL;
    for (int i = 0; i < tree.n; i++)
    {
        if (tree.tns[i].parent && tree.tns[i].parent->data == root->data)
        {
            BiTreeNode* newChild = &bitree.btns[i];
            if (currentChild == NULL)
            {
                root->leftChild = newChild;
            }
            else
            {
                currentChild->rightBrother = newChild;
            }
            currentChild = newChild;
            findChild(currentChild, tree);
        }
    }
}
BiTree treeToBiTree(Tree tree)
{
    bitree.r = 0;
    bitree.n = tree.n;
    for (int i = 0; i < bitree.n; i++)
    {
        bitree.btns[i].data = tree.tns[i].data;
        bitree.btns[i].leftChild = NULL;
        bitree.btns[i].rightBrother = NULL;
    }
    BiTreeNode* root = &bitree.btns[0];
    findChild(root, tree);
    return bitree;
}

void levelOrderTraversal(BiTreeNode* root)
{
    if (root == NULL)
    {
        return;
    }

    QueueNode* queue = NULL;
    enqueue(&queue, root);

    while (queue != NULL)
    {
        BiTreeNode* node = dequeue(&queue);
        printf("%d ", node->data);

        if (node->leftChild != NULL)
        {
            enqueue(&queue, node->leftChild);
        }

        if (node->rightBrother != NULL)
        {
            enqueue(&queue, node->rightBrother);
        }
    }
}

 上述程序中利用parent数组创建的树以及转换成二叉树的形式如左图所示。

该二叉树用层次遍历法打印结果为：
1 2 5 3 6 4 7 8 9 10
与程序运行结果一致。
 

运行结果如下：

1 2 5 3 6 4 7 8 9 10
D:\Cfiles\DSweek8\Debug\DSweek8.exe (进程 19512)已退出，代码为 0。
按任意键关闭此窗口. . .

三、根据遍历结果创建二叉树 

在遍历过程中生成结点，建立二叉树的存储结构。以先序遍历法为例，按照下列次序顺序读入字符：
A  B  C  \Phi  \Phi  D  E  \Phi  G  \Phi  \Phi  F  \Phi  \Phi  \Phi 
，其中\Phi表示空格字符，可以建立相应的二叉链表如左图。

代码实现

读入上文所给的字符串示例（先序遍历），创建二叉树，并打印中序遍历的结果。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h> 
#define MAX_NUM 20

typedef struct btNode
{
	char data;
	struct btNode* lChild;
	struct btNode* rBrother;
}btNode;

btNode* createTree(FILE* fp); 
void printTree(btNode* root);

int main()
{
	char* filename = "D:\\Cfiles\\exFILE\\bTree_char.txt";
	FILE* fp = fopen(filename, "r"); 
	if (fp == NULL)
	{
		printf("打开文件错误");
		return -1; 
	}

	//1、读入字符文件创建二叉树
	btNode* root = createTree(fp); 

	//2、打印二叉树信息
	printTree(root);

	fclose(fp); 

	return 0;
}

btNode* createTree(FILE* fp) 
{
	char ch;
	fscanf(fp, "%c", &ch); 

	if (ch == ' ')
	{
		return NULL;
	}
	else
	{
		btNode* root = (btNode*)malloc(sizeof(btNode)); 
		root->data = ch;
		root->lChild = createTree(fp); 
		root->rBrother = createTree(fp); 
		return root;
	}
}

void printTree(btNode* root)
{
	if (root == NULL)
	{
		return;
	}
	printTree(root->lChild);
	printf("%c ", root->data);
	printTree(root->rBrother);
}
运行结果：

C B E G D F A
D:\专业学习\大二下\DS\DSweek12\Debug\DSweek12.exe (进程 9728)已退出，代码为 0。
按任意键关闭此窗口. . .

想法：

二叉树和图的遍历类似，深度优先/先根遍历这些都可以用堆栈代替递归算法，而宽度优先/层次遍历可以用队列。

熊猫_luoul
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
遍历二叉树的代码实现
1+1=王的博客
08-08 1598
二叉树的遍历先序遍历（根--左--右）递归法非递归法中序遍历（左--根--右）递归法非递归法后序遍历（左--右--根）递归法非递归法层序遍历 先序遍历（根–左--右） 递归法 void PreOrder(BiTree T){ if(T != NULL){ visit(T); //访问根节点 PreOrder(T->lchild); //递归遍历左子树 PreOrder(T->rchild); //递归遍历右子树 } } 非递归法 void PreOrder(BiTree
二叉树遍历详解（附完整代码）
shassd的博客
10-11 7322
二叉树的遍历： 一：最常见的遍历种类 先序遍历 中序遍历 后序遍历 层次遍历 二：遍历的递归代码实现分别给出Java 代码和C代码实现 //Java代码实现 //二叉树的定义 * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } * //前序遍历 public void preOrder(TreeNode root){ if (r
二叉树的遍历（含代码）
Borisplus的博客
11-09 1957
**二叉树的遍历** 建立二叉树时，使用递归思想，若为‘ ’则为NULL，节点不存在，否则开辟新空间，存入数据 若为先序 则先存，后左右 若为中序 先左 再存 后右 若为后序 先左右 再存 后序遍历，使用递归思想，先一直访问左，再一直访问右边，最后打印根数据 非递归遍历，中序输出，中序为 左根右 需要借助栈 先访问左直至空 ...
数据结构笔记：二叉树的遍历与技巧
submarineas的博客
04-22 1191
遍历是数据结构中常见的操作，主要是将所有元素都访问一遍。对于线性结构来说，遍历分为两种：正序遍历和逆序遍历。前序遍历（Preorder Traversal）中序遍历(Inorder Traversal)后序遍历(Postorder Traversal)层序遍历(Levelorder Traversal)int data;
【C语言 数据结构】二叉树的遍历
HR的博客
02-06 7858
按照层次从左往右输入树中结点的值，0 表示空结点，# 表示输入结束:1 2 3 4 5 6 7 #按照层次从左往右输入树中结点的值，0 表示空结点，# 表示输入结束:1 2 3 4 5 6 7 #
Python实现二叉树结构与进行二叉树遍历的方法详解
09-21
二叉树遍历主要有四种方式：前序遍历、中序遍历、后序遍历和层次遍历。 1. **前序遍历**：先访问根节点，然后遍历左子树，最后遍历右子树。 2. **中序遍历**：先遍历左子树，然后访问根节点，最后遍历右子树。 3. *...
JS中的二叉树遍历详解
10-22
二叉树遍历是指按照特定顺序访问二叉树的所有节点。本文将详细介绍JS中二叉树的遍历方法。 首先，我们要了解三种主要的遍历方式： 1. 广度优先遍历（Breadth-First Search, BFS）： 广度优先遍历从根节点开始，...
PHP实现的线索二叉树及二叉树遍历方法详解
01-20
本文实例讲述了PHP实现的线索二叉树及二叉树遍历方法。分享给大家供大家参考，具体如下： <?php require 'biTree.php'; $str = 'ko#be8#tr####acy#####'; $tree = new BiTree($str); $tree->...
二叉树的遍历方法（C语言）
liuchiang03的博客
06-24 7032
二叉树的各种遍历方法
二叉树及其遍历方式+代码
weixin_50901244的博客
02-22 3500
二叉树及其遍历方式1、树型结构及基本概念1.1 树型结构概念1.2 一些重要概念2. 二叉树及基本概念2.1 二叉树概念2.2 两种特殊的二叉树2.3 二叉树的性质2.4 二叉树的存储2.5 二叉树的基本操作2.5.1 二叉树的遍历2.5.2 代码 1、树型结构及基本概念 1.1 树型结构概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树型结构的特点 子树不相交 除根节点外，每个节点有
二叉树的遍历程序(C语言版)
12-04
此资源为二叉树遍历算法演示的C语言代码，为本科某小白亲自写完并调试成功的代码
遍历二叉树程序
09-28
遍历二叉树程序，亲自调试，注释详尽，有不懂的随时和大家交流，希望能帮到大家~
树/二叉树 各种遍历源代码(C++)
04-17
树的前序, 后序和层序遍历 二叉树的前序, 中序, 后序和层序遍历 以上每种遍历提供三种方式 1. 普通遍历: 自己构造栈或队列 2. 递归遍历 3. 迭代器遍历
数据结构—二叉树的4种遍历方式详解以及Java代码的完整演示
终生学习践行者
04-24 6939
本文介绍了4种二叉树的遍历方法，分别是前序、中序、后续、层序遍历，并且每种方法均提供了详尽的Java语言的代码演示，在最后还介绍了遍历结果推导的方法。
二叉树层次遍历代码完整代码（C语言）
xiuhhhua的博客
08-06 7867
二叉树层次遍历思路就是使用队列进行存储，当出队一个元素，则将其左右子树入队。
遍历二叉树、恢复二叉树（java代码实现）
记录知识，学习分享
10-07 654
根 左子树 右子树 根 左子树 右子树。（2）由确定的左、右子树根据前序序列分别找出左、右子树的根结点，并把左、右子树的根结点连接到父结点。（2）由确定的左、右子树根据后序序列分别找出左、右子树的根结点，并把左、右子树的根结点连接到父结点。（3）分别对左、右子树实行步骤（1）和（2），直到子树只剩下1个结点或2个结点或空为止。（3）分别对左、右子树实行步骤（1）和（2），直到子树只剩下1个结点或2个结点或空为止。（1）由后序序列获知根结点，然后根据中序序列确定左、右子树。
Python算法——二叉树遍历
最新发布
Echo_Wish的博客
11-10 855
这些遍历算法是在不同情况下解决二叉树问题时非常有用的工具。了解它们的工作原理，并能够实现相应的算法，有助于深入理解树结构的特性。前序遍历按照“根-左-右”的顺序访问二叉树节点。中序遍历按照“左-根-右”的顺序访问二叉树节点。后序遍历按照“左-右-根”的顺序访问二叉树节点。
二叉树的遍历及其应用C/C++代码实现
Ycy的博客
06-08 8094
二叉树的存储结构： 顺序存储：只适合完全二叉树。 链式存储：利用这种结点结构所得二叉树的存储结构分别称之为二叉链表和三叉链表。 二叉树的遍历： 规定先左后右，按照根结点的访问次序可分为先（根） 序遍历、中（根） 序遍历和后（根） 序遍历。 先序遍历序列：ABCDEGF 中序遍历序列：CBEGDFA 后序遍历序列：CGEFDBA 注意： 另外由二叉树的先序序列和中序序列，或由其后序序列和中序序列均能唯一地确定一棵二叉树。 但先序序列和后序序列不能唯一确定一棵二叉树。 遍历的应用： 1，建立二叉链表 2，复
二叉树已知前序中序求后序代码详解
05-19
二叉树的前序遍历顺序为：根节点、左子树、右子树；中序遍历顺序为：左子树、根节点、右子树。因此，如果已知一个二叉树的前序遍历和中序遍历，就可以推导出该二叉树的后序遍历。 具体实现方法如下： 1. 定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值