建立二叉链表存储的二叉树+遍历二叉树(先序、中序、后序、层序)
1.建立二叉链表存储的二叉树
1-1.原理
二叉树的构建利用了递归的原理，在按先序序列构建二叉树时，为了能让电脑知道每个结点是否有左右孩子，我们要对原二叉树进行扩展，明确表示每个结点的左右孩子，若当前结点没有左右孩子，我们用’#'表示。
由普通二叉树---->扩展二叉树，如下图：
此时当我们按先序序列构建上面的二叉树时，应输入的序列为：AB#D##C##
1-2.代码
void CreateBiTree(BiTree *T) // 二叉树的构造
{
char ch;
scanf("%c", &ch);
if (ch == '#') *T = NULL; // #表示当前结点为空
else {
*T = (BiTree)malloc(sizeof(BiTNode)); // 动态申请结点内存
(*T)->data = ch; // 生成根结点
CreateBiTree(&(*T)->lchild); // 构造左子树
CreateBiTree(&(*T)->rchild); // 构造右子树
}
}
1-3.实例
以下图的二叉树为例：（后面的实例均以该二叉树为例）
#include <iostream>
using namespace std;
const int N = 100;
typedef struct BiTNode
{
char data;
BiTNode *lchild;
BiTNode *rchild;
} BiTNode, *BiTree;
void CreateBiTree(BiTree *T) // 建立二叉链表存储的二叉树
{
char ch;
scanf("%c", &ch);
if (ch == '#') *T = NULL; // #表示当前结点为空
else {
*T = (BiTree)malloc(sizeof(BiTNode)); // 动态申请结点内存
(*T)->data = ch; // 生成根结点
printf("%c", (*T)->data); // 检验建立的顺序
CreateBiTree(&(*T)->lchild); // 构造左子树
CreateBiTree(&(*T)->rchild); // 构造右子树
}
}
int main()
{
BiTree T;
CreateBiTree(&T);
return 0;
}
2.先序遍历
2-1.递归
若二叉树为空，则返回；否则先访问根结点，然后先序遍历左子树，最后先序遍历右子树。
void PreOrderTraverse(BiTree T) // 先序遍历二叉树
{
if (T == NULL) return;
printf("%c", T->data); // 先显示结点数据
PreOrderTraverse(T->lchild); // 再先序遍历左子树
PreOrderTraverse(T->rchild); // 最后先序遍历右子树
}
2-2.非递归
用栈来实现：
（1）首先访问根结点，根节点入栈并进去其左子树，然后访问左子树的根节点，入栈并进入下一层的左子树，直到当前结点为空。
（2）若栈此时非空，则从栈中退出栈顶元素，进入该结点的右子树。
重复（1）（2），直到当前结点和栈都是空的，结束。
void PreOrder(BiTree T) // 先序遍历二叉树（非递归）
{
BiTNode *s[N]; // 用结构体指针数组模拟栈
int top = 0; // 设置栈顶指针
BiTNode *p;
p = T;
while (top != 0 || p != NULL) { // 若当前结点为空结点 且 栈为空，则结束
while (p != NULL) { // 若当前结点不为空，则访问根结点，根指针入栈，进入左子树
printf("%c", p->data);
s[++top] = p;
p = p->lchild;
}
if (top != 0) { // 若栈不为空，根指针退栈，进入其右子树
p = s[top--];
p = p->rchild;
}
}
}
2-3.实例
测试输入：ab#d##c##
测试输出：abdc
#include <iostream>
using namespace std;
const int N = 100;
typedef struct BiTNode
{
char data;
BiTNode *lchild;
BiTNode *rchild;
} BiTNode, *BiTree;
void CreateBiTree(BiTree *T) // 建立二叉链表存储的二叉树
{
char ch;
scanf("%c", &ch);
if (ch == '#') *T = NULL; // #表示当前结点为空
else {
*T = (BiTree)malloc(sizeof(BiTNode)); // 动态申请结点内存
(*T)->data = ch; // 生成根结点
CreateBiTree(&(*T)->lchild); // 构造左子树
CreateBiTree(&(*T)->rchild); // 构造右子树
}
}
void PreOrderTraverse(BiTree T) // 先序遍历二叉树（递归）
{
if (T == NULL) return;
printf("%c", T->data);
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
void PreOrder(BiTree T) // 先序遍历二叉树（非递归）
{
BiTree s[N];
int top = 0;
BiTree p;
p = T;
while (p != NULL || top != 0) { // 若当前结点非空，或者栈不为空
while (p != NULL) { // 依次访问左子树，并入栈
printf("%c", p->data);
s[++top] = p;
p = p->lchild;
}
if (top != 0) { // 返回栈顶元素，及当前结点的根节点，并进入根节点的右子树
p = s[top--];
p = p->rchild;
}
}
}
int main()
{
BiTree T;
CreateBiTree(&T);
PreOrderTraverse(T);
printf("\n");
PreOrder(T);
return 0;
}
3.中序遍历
3-1.递归
若二叉树为空，则返回；否则先中序遍历左子树，然后访问根结点，最后中序遍历右子树。
void InOrderTraverse(BiTree T)
{
if (T == NULL) return;
InOrderTraverse(T->lchild);
printf("%c", T->data);
InOrderTraverse(T->rchild);
}
3-2.非递归
用栈实现：
（1）根结点入栈，进入其左子树，进而左子树的根结点入栈，进入下一层的左子树，直到当前结点为空。
（2）若栈不为空，从栈顶退出上一层的结点，访问此结点，并进入该结点的右子树。
重复执行（1）（2），直到当前结点和栈均为空，结束。
void InOrder(BiTree T) // 中序遍历二叉树（非递归）
{
BiTNode *s[N]; // 用结构体指针数组模拟栈
int top = 0; // 设置栈顶指针
BiTNode *p;
p = T;
while (top != 0 || p != NULL) { // 若当前结点为空结点 且 栈为空，则结束
while (p != NULL) { // 若当前结点不为空，则访问根结点，根指针入栈，进入左子树
s[++top] = p;
p = p->lchild;
}
if (top != 0) { // 若栈不为空，根指针退栈，进入其右子树
p = s[top--];
printf("%c", p->data); // 先访问完左结点之后，回到根结点，再访问根节点
p = p->rchild;
}
}
}
3-3.实例
测试输入：ab#d##c##
测试输出：bdac
#include <iostream>
using namespace std;
const int N = 100;
typedef struct BiTNode // 二叉树的结点结构
{
char data; // 结点数据
BiTNode *lchild;
BiTNode *rchild; // 左右孩子指针
} BiTNode, *BiTree;
void CreateBiTree(BiTree *T) // 建立二叉链表存储的二叉树
{
char ch;
scanf("%c", &ch);
if (ch == '#') *T = NULL; // #表示当前结点为空
else {
*T = (BiTree)malloc(sizeof(BiTNode)); // 动态申请结点内存
(*T)->data = ch; // 生成根结点
CreateBiTree(&(*T)->lchild); // 构造左子树
CreateBiTree(&(*T)->rchild); // 构造右子树
}
}
void InOrderTraverse(BiTree T) // 中序遍历二叉树（递归）
{
if (T == NULL) return;
InOrderTraverse(T->lchild); // 先中序遍历左子树
printf("%c", T->data); // 再显示结点数据
InOrderTraverse(T->rchild); // 最后中序遍历右子树
}
void InOrder(BiTree T) // 中序遍历二叉树（非递归）
{
BiTNode *s[N]; // 用结构体指针数组模拟栈
int top = 0; // 设置栈顶指针
BiTNode *p;
p = T;
while (top != 0 || p != NULL) { // 若当前结点为空结点 且 栈为空，则结束
while (p != NULL) { // 若当前结点不为空，则访问根结点，根指针入栈，进入左子树
s[++top] = p;
p = p->lchild;
}
if (top != 0) { // 若栈不为空，根指针退栈，进入其右子树
p = s[top--];
printf("%c", p->data); // 先访问完左结点之后，回到根结点，再访问根节点
p = p->rchild;
}
}
}
int main()
{
BiTree T;
CreateBiTree(&T);
InOrderTraverse(T);
printf("\n");
InOrder(T);
return 0;
}
4.后序遍历
4-1.递归
若二叉树为空，则返回；否则先后序遍历左子树，然后访问根结点，最后后序遍历右子树。
void PostOrderTraverse(BiTree T)
{
if (T == NULL) return;
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
printf("%c", T->data);
}
4-2.非递归
同样用栈来实现：
（1）根结点入栈，进入其左子树，进而左子树的根结点入栈，进入下一层左子树，直到当前结点为空。
（2）若栈非空，如果栈顶结点p的右子树为空或者已经被访问过，则退出栈，访问p结点，并将p赋值给q，p置为空；如果栈顶结点有右子树且未被访问，则进入p的右子树。
重复执行（1）（2），直到当前结点和栈均为空，结束。
void PostOrder(BiTree T) // 后序遍历二叉树（非递归）
{
BiTNode *s[N];
int top = 0;
BiTNode *p, *q; // q存储刚刚访问过的结点，p存储当前根结点
p = T;
q = NULL;
while (p != NULL || top != 0) {
while (p != NULL) {
s[++top] = p;
p = p->lchild;
}
if (top != 0) {
p = s[top]; // 获取栈顶元素
if (p->rchild == NULL || p->rchild == q) { // 若右子树为空 或者 右子树刚刚被访问过
top--; // 栈顶元素出栈
printf("%c", p->data);
q = p;
p = NULL;
}
else {
p = p->rchild;
}
}
}
}
4-3.实例
测试输入：ab#d##c##
测试输出：dbca
#include <iostream>
using namespace std;
const int N = 100;
typedef struct BiTNode // 二叉树的结点结构
{
char data; // 结点数据
BiTNode *lchild, *rchild; // 左右孩子指针
} BiTNode, *BiTree;
void CreateBiTree(BiTree *T) // 建立二叉链表存储的二叉树
{
char ch;
scanf("%c", &ch);
if (ch == '#') *T = NULL; // #表示当前结点为空
else {
*T = (BiTree)malloc(sizeof(BiTNode)); // 动态申请结点内存
(*T)->data = ch; // 生成根结点
CreateBiTree(&(*T)->lchild); // 构造左子树
CreateBiTree(&(*T)->rchild); // 构造右子树
}
}
void PostOrderTraverse(BiTree T) // 后序遍历二叉树（递归）
{
if (T == NULL) return;
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
printf("%c", T->data);
}
void PostOrder(BiTree T) // 后序遍历二叉树（非递归）
{
BiTNode *s[N];
int top = 0;
BiTNode *p, *q; // q存储刚刚访问过的结点，p存储当前根结点
p = T;
q = NULL;
while (p != NULL || top != 0) {
while (p != NULL) {
s[++top] = p;
p = p->lchild;
}
if (top != 0) {
p = s[top]; // 获取栈顶元素
if (p->rchild == NULL || p->rchild == q) { // 若右子树为空 或者 右子树刚刚被访问过
top--; // 栈顶元素出栈
printf("%c", p->data);
q = p;
p = NULL;
}
else {
p = p->rchild;
}
}
}
}
int main()
{
BiTree T;
CreateBiTree(&T);
PostOrderTraverse(T);
printf("\n");
PostOrder(T);
return 0;
}
5.层序遍历
5-1.层序遍历代码
层序遍历用队列来实现，首先根结点入队，当队列非空时，重复执行下面两个操作：
（1）队头结点出队，访问出队结点。
（2）出队结点的非空左右孩子入队。
void LevelOrder(BiTree T) // 二叉树的层序遍历
{
BiTNode *Q[N]; // 数组模拟队列
int front = 0;
int rear = 0;
BiTNode *p;
Q[++rear] = T; // 根结点入队
while (front != rear) { // 若队列不为空
// 队头结点出队，并访问出队结点
p = Q[++front];
printf("%c", p->data);
// 出队结点的非空左右孩子依次入队
if (p->lchild != NULL) {
Q[++rear] = p->lchild;
}
if (p->rchild != NULL) {
Q[++rear] = p->rchild;
}
}
}
5-2.实例
测试输入：ab#d##c##
测试输出：abcd文章来源：https://www.toymoban.com/news/detail-465317.html
#include <iostream>
using namespace std;
const int N = 100;
typedef struct BiTNode
{
char data;
BiTNode *lchild;
BiTNode *rchild;
} BiTNode, *BiTree;
void CreateBiTree(BiTree *T) // 建立二叉链表存储的二叉树
{
char ch;
scanf("%c", &ch);
if (ch == '#') *T = NULL; // #表示当前结点为空
else {
*T = (BiTree)malloc(sizeof(BiTNode)); // 动态申请结点内存
(*T)->data = ch; // 生成根结点
CreateBiTree(&(*T)->lchild); // 构造左子树
CreateBiTree(&(*T)->rchild); // 构造右子树
}
}
void LevelOrder(BiTree T) // 二叉树的层序遍历
{
BiTNode *Q[N]; // 数组模拟队列
int front = 0;
int rear = 0;
BiTNode *p;
Q[++rear] = T; // 根结点入队
while (front != rear) { // 若队列不为空
// 队头结点出队，并访问出队结点
p = Q[++front];
printf("%c", p->data);
// 出队结点的非空左右孩子依次入队
if (p->lchild != NULL) {
Q[++rear] = p->lchild;
}
if (p->rchild != NULL) {
Q[++rear] = p->rchild;
}
}
}
int main()
{
BiTree T;
CreateBiTree(&T);
LevelOrder(T);
return 0;
}
内容参考：
《大话数据结构》 程杰
《数据结构与算法》王曙燕文章来源地址https://www.toymoban.com/news/detail-465317.html
到了这里，关于【树】建立二叉链表存储的二叉树+遍历二叉树(先序、中序、后序、层序)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
