当前位置：首页 > news >正文

链式二叉树算法精讲：前中后序、层序与完全二叉树判断

news 2025/11/1 13:03:45

前言
一、实现链式结构二叉树
- 1.1 前中后序遍历
- 1.2 结点个数以及高度等
- - 1.2.1 二叉树结点个数
  - 1.2.2 二叉树叶子结点个数
  - 1.2.3 二叉树第k层结点个数
  - 1.2.4 二叉树的深度/高度
  - 1.2.5 二叉树查找值为x的节点
  - 1.2.6 二叉树销毁
- 1.3 层序遍历
- 1.4 判断是否为完全二叉树
二、链式结构二叉树完整源码
结语

在这里插入图片描述

🎬 云泽Q：个人主页
🔥 专栏传送入口: 《C语言》《数据结构》《C++》《Linux》

⛺️遇见安然遇见你，不负代码不负卿~

前言

大家好啊，我是云泽Q，欢迎阅读我的文章，一名热爱计算机技术的在校大学生，喜欢在课余时间做一些计算机技术的总结性文章，希望我的文章能为你解答困惑~

一、实现链式结构二叉树

用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个节点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点的左孩子和右孩子所在的链结点的存储地址，其结构如下：
在这里插入图片描述
在链式结构的二叉树中，初始的情况下是个空树（连根节点都没有）

之前实现顺序结构二叉树是通过实现堆这个数据结构来实现的，而堆本身就是个完全二叉树（除了最后一层，每层结点个数达到最大，而且节点从左到右依次排列）
但是要实现链式结构的二叉树（普通二叉树），插入第一个节点必定是根节点，而然放第二个结点的位置就有了选择，放第三个结点的选择就更多了，所以普通二叉树的插入和删除是没有意义的，其限制太少，对于链式结构的二叉树，其中重要的操作就是遍历

链式结构的二叉树是一个递归的结构，想递归，就要遍历，在链式结构的二叉树中，主要有四种遍历的方式：前中后以及层序遍历

1.1 前中后序遍历

在这里插入图片描述
前序遍历逻辑补充：这里遍历到D这棵左子树后发现其是一棵二叉树，所以就会遍历根节点D，但D也是叶子节点（无左右孩子），之后又会继续遍历D的左子树，发现左子树为空。就不会遍历左NULL了，而是回到D节点，此时根左遍历完了遍历根右，发现根右为空，继续返回到D节点，此时D这棵子树遍历完了（图中NUL写出来是为了让遍历的逻辑可读性更高）继续向上回到B节点，在B这颗二叉树中，根左遍历完了，接下来会遍历根右，依次类推，直到F这棵二叉树根左右都遍历完成，就会回到C这个节点，然后回到A节点，由于A节点左右子树都遍历完了，就会继续向上走，至此，这棵二叉树的前序遍历就完成了

//前序遍历 - 根左右
void PreOrder(BTNode* root);
//中序遍历 - 左根右
void InOrder(BTNode* root);
//后序遍历 - 左右根
void PostOrder(BTNode* root);

在这里插入图片描述

这里详细说一下其前序遍历递归的过程（图中红色是创建函数栈帧，绿色是释放函数栈帧）：
初始情况下A打印之后递归A的左孩子B，创建新的函数栈帧B，打印B之后继续递归B的左孩子D，打印D之后，在D的函数栈帧中继续进行递归调用，创建D左孩子（NULL）的函数栈帧，打印NULL之后return（当前函数执行结束），函数栈帧销毁之后来到D的栈帧，在D的栈帧中，根节点已经打印完成，左子树已经递归完了，接下来递归D的右孩子节点（NULL），在新的栈帧中打印完NULL之后栈帧销毁，回到D的函数栈帧，此时D栈帧的代码就全部执行完了，D函数栈帧的销毁是因为代码执行完而销毁的。D销毁之后回到B的函数栈帧，在B的栈帧中，左子树递归完了就要递归右子树（NULL），打印NULL之后，NULL这个函数栈帧就销毁了，就return销毁栈帧，回到B的栈帧之中，B栈帧因为代码执行完成而销毁。此时回到A的栈帧之中，A栈帧根节点打印了，左子树递归完成，开始递归右子树（C），以此类推，循环往复。直到F右子树（NULL）的值打印并且其栈帧销毁之后回到F，F的代码逻辑执行完了，就要回到C结点的栈帧，C的代码逻辑也执行完了，C的栈帧销毁，回到A栈帧。A栈帧的代码逻辑此时也全部执行完了，就要销毁栈帧彻底结束

1.2 结点个数以及高度等

1.2.1 二叉树结点个数

统计结点个数依旧使用递归，前面的三种递归方法都可以，只要节点不为空，size就++

这里的size不能定义为局部变量，否则在递归的过程中，每个栈帧中都有一个size，这些size相互独立
在这里插入图片描述

可以看到，如果多次调用该函数求二叉树节点个数就会出问题

第一个方法是在树的结构中加一个size变量，但是这样每创建一个节点，这个节点的大小将会大不止4个字节（还涉及内存对齐），所以这种解决方案不划算

第二中解决方案是在形参位置加一个size，最后作为一个参数去返回（不作为返回值返回），这样size既不是函数体内的局部变量，也不是全局变量
在这里插入图片描述

但是结果依旧不对，原因就是这里的size要传指针，传值返回形参的改变并不会影响实参

实参size和形参size虽然同名，但并不是同一个变量，实参size只是把值给了形参size，而且例如在A栈帧和B栈帧的size之间也没有任何关系，A栈帧只是把size的值传给了B栈帧，若改同一个变量就要传地址
在这里插入图片描述

该代码还可以优化的更好用
前面求二叉树总的节点个数的逻辑：根节点（有且仅有一个）+左子树节点个数+右子树节点个数

1.2.2 二叉树叶子结点个数

叶子节点：没有左右孩子节点（即度为0）
在这里插入图片描述

1.2.3 二叉树第k层结点个数

假设现在K为3（求叶子节点个数）,依旧从根结点开始，在A的函数栈帧中K为3，此时K=3不是想要求解节点个数的层数，所以就向下递归，先去递归A的左孩子B，创建了B的函数栈帧，然后K减减，在B的函数栈帧中K为2，此时依旧不是要求解节点个数的层数，此时再递归B的左子树，在D的栈帧中，K由2变为1，当K为1时，这一层就是要求的第K层节点个数了

若K为1，且节点不为空，就return 1，在B的函数栈帧里，左子树中第K层节点个数的知道了，接下来看右子树第K层结点个数，右子树为NULL，就return 0（右子树第K层节点个数为0），把左右子树中第K层结点个数累加起来return 1给A，在A的函数栈帧中，左子树中第K层结点个数为1，接下来递归右子树C，K由3变为2，此时K不为1，继续向下递归，来到E栈帧，K为1，且节点不为空，直接return 1给C，C的左子树递归完后递归其右子树，C的右子树节点不为空且K为1，便直接return 1给C栈帧，在C这个二叉树中，左子树第K层结点个数为1，右子树第K层节点个数为1，return 2给A栈帧，回到A的函数栈帧中，左子树第K层结点个数为1，右子树第K层结点个数为2，最终返回3
在这里插入图片描述

1.2.4 二叉树的深度/高度

依旧是从根节点出发求二叉树的深度/高度
在这里插入图片描述

1.2.5 二叉树查找值为x的节点

在这里插入图片描述

1.2.6 二叉树销毁

前面的操作没有修改根节点，而销毁因为传参要传指向根节点指针的地址，所以形参用二级指针来接收

链表是使用遍历的方式销毁的，二叉树这里也可以，但是不可以前序遍历（根左右），如果先销毁了根节点，就不能寻找左子树了，所以要用后序遍历（左右根），最后再销毁根节点
在这里插入图片描述
因为形参是二级指针，所以要传一级指针（（* root->left）取left成员，left成员是一级指针）的地址，取一级指针的地址，用二级指针接收

1.3 层序遍历

除了先序遍历、中序遍历、后序遍历外（这些称为深度优先遍历），还可以堆二叉树进行层序遍历（广度优先遍历）。设二叉树的根节点所在层数为1.层序遍历就是从所在二叉树的根结点出发，首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历

实现层序遍历需要额外借助数据结构：队列
在这里插入图片描述
首先将根节点保存在队列中，使队列不为空，循环判断队列是否为空，不为空取队头，将队头结点不为空的孩子结点入队列

A结点不为空，取队头，将A结点的孩子结点入队列

循环往复

这里要使用数据结构队列，就要队列的实现代码，直接手搓一个队列，在二叉树的.c文件中包含其.h文件即可
注意：往队列中插入的是二叉树的结点，二叉树存储的数据类型是一个二叉树节点的数据类型，但是在队列的结构中，存储的数据类型是QDataType（int）
在这里插入图片描述
应该要把Int改为指向二叉树节点的的指针，之所以在队列中选择存储 “二叉树节点的指针” 而非 “节点结构本身”（typedef struct BinaryTreeNode QDataType;），核心原因是内存效率、操作性能和逻辑合理性

现在队列的元素可以存储二叉树节点的指针了，在队列的头文件使用了BinaryTreeNode，但是BinaryTreeNode在当前队列的头文件中是找不到的，但是也不能包含二叉树的头文件.h，这里若再包含二叉树的头文件会有报错，因为前面为了使用队列的结构，已经在Tree.c文件中包含了队列的头文件，若在队列的头文件中包含二叉树的头文件，这就是头文件的嵌套包含了，所以这里隐含的使用了前置声明

在 typedef struct BinaryTreeNode* QDataType; 中，struct BinaryTreeNode 就是一个前置声明。它的作用是：告诉编译器 “存在一个名为 struct BinaryTreeNode 的结构体类型”，但暂时不说明这个结构体里有哪些成员。
在这里插入图片描述
但是前置声明的使用也有限制：

而且必须加struct关键字，这个关键字的作用就是告诉编译器BinaryTreeNode* 有这么个二叉树的结构在这里没有实现，也没有定义

1.4 判断是否为完全二叉树

完全二叉树的特点：
在这里插入图片描述
这里的思路就是

第二个点依旧是一个广度遍历，所以还要借助数据结构队列，只不过稍微有一些改变：
依旧是根结点先入队列，保证队列不为空，循环判断队列是否为空，不为空取队头，出队头，将队头节点的左右孩子（不再是不为空的孩子结点）都入队列

先看非完全二叉树
在这里插入图片描述

这次取队头是B的右孩子，为空，就不能对空结点解引用取空节点的左右孩子入队列了

在这里插入图片描述
所以取到空的队头，就跳出循环，此时队列中剩下了，空结点和非空结点

再来看完全二叉树，再按照刚刚的逻辑推理一遍
在这里插入图片描述

这里E的左右孩子两个NULL没有画，实际上是有的

此时队列不为空，再取队头，出队头，队头节点为空，不能将其左右孩子入队列了，此时就跳出循环，队列中剩下的全部都是空结点

所以用队列判断当前二叉树是否为完全二叉树的方法就是，跳出循环之后，循环取队列中剩下的结点，如果剩下的节点中存在非空结点，其一定不是完全二叉树，反之剩下的全部都是空结点，就是完全二叉树

在这里插入图片描述

二、链式结构二叉树完整源码

Tree.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>//定义二叉树节点结构
typedef char BTDataType;
typedef struct BinaryTreeNode {BTDataType data;struct BinaryTreeNode* left; //指向当前节点左孩子struct BinaryTreeNode* right;//指向当前节点右孩子
}BTNode;//前序遍历 - 根左右
void PreOrder(BTNode* root);
//中序遍历 - 左根右
void InOrder(BTNode* root);
//后序遍历 - 左右根
void PostOrder(BTNode* root);
//二叉树节点个数
int BinaryTreeSize(BTNode* root);
//void BinaryTreeSize(BTNode* root, int* psize);//二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root);
//二叉树第k层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
//二叉树的深度/高度
int BinaryTreeDepth(BTNode* root);
//二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
//二叉树销毁
void BinaryTreeDestory(BTNode** root);
//层序遍历
void LevelOrder(BTNode* root);
//判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);

Queue.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
//嵌套包含
//#include"Tree.h"//typedef int QDataType;
//int更改为二叉树节点结构
//前置声明
typedef struct BinaryTreeNode* QDataType;
//还可以使用下面
//typedef struct BTNode* QDataType;//定义节点结构
typedef struct QueueNode {QDataType data;struct QueueNode* next;
}QueueNode;//定义队列的结构
typedef struct Queue {QueueNode* phead; //队头QueueNode* ptail; //队尾//int size;         //队列中有效数据个数
}Queue; //初始化
void QueueInit(Queue* pq);
//销毁
void QueueDesTroy(Queue* pq);//入队列
void QueuePush(Queue* pq, QDataType x);
//出队列
void QueuePop(Queue* pq);
//取队头数据
QDataType QueueFront(Queue* pq);
//取队尾数据
QDataType QueueBack(Queue* pq);bool QueueEmpty(Queue* pq);
//队列有效元素个数
int QueueSize(Queue* pq);

Queue.c

#include"Queue.h"//初始化
void QueueInit(Queue* pq)
{assert(pq);pq->phead = pq->ptail = NULL;
}//入队列
void QueuePush(Queue* pq, QDataType x)
{assert(pq);//创建值为x的节点QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));if (newnode == NULL){perror("malloc fail!");exit(1);}newnode->data = x;newnode->next = NULL;//队列为空if (pq->phead == NULL){pq->phead = pq->ptail = newnode;}else {pq->ptail->next = newnode;pq->ptail = pq->ptail->next;}	
}
bool QueueEmpty(Queue* pq)
{assert(pq);return pq->phead == NULL;
}
//出队列
void QueuePop(Queue* pq)
{assert(!QueueEmpty(pq));//队列中只有一个节点if (pq->phead == pq->ptail){free(pq->phead);pq->phead = pq->ptail = NULL;}else {QueueNode* next = pq->phead->next;free(pq->phead);pq->phead = next;}
}//取队头数据
QDataType QueueFront(Queue* pq)
{assert(!QueueEmpty(pq));return pq->phead->data;
}
//取队尾数据
QDataType QueueBack(Queue* pq)
{assert(!QueueEmpty(pq));return pq->ptail->data;
}
//队列有效元素个数
int QueueSize(Queue* pq)
{assert(pq);QueueNode* pcur = pq->phead;int size = 0;while (pcur){++size;pcur = pcur->next;}return size;//return pq->size;
}
//销毁
void QueueDesTroy(Queue* pq)
{assert(pq);QueueNode* pcur = pq->phead;while (pcur){QueueNode* next = pcur->next;free(pcur);pcur = next;}pq->phead = pq->ptail = NULL;
}

Tree.c

#include"Tree.h"
#include"Queue.h"//前序遍历 - 根左右
void PreOrder(BTNode* root)
{//遍历到空节点直接结束if (root == NULL){printf("NULL ");return;}//打印根节点printf("%c ", root->data);//遍历左右孩子，左右孩子还是二叉树，重复操作根左右PreOrder(root->left);PreOrder(root->right);
}//中序遍历 - 左根右
void InOrder(BTNode* root)
{if (root == NULL){printf("NULL ");return;}//左根右InOrder(root->left);printf("%c ", root->data);InOrder(root->right);
}//后序遍历 - 左右根
void PostOrder(BTNode* root)
{if (root == NULL){printf("NULL ");return;}PostOrder(root->left);PostOrder(root->right);printf("%c ", root->data);
}//错误：创建全局变量，多次调用方法会出现累加的情况
//int size = 0;
////二叉树节点个数
//int BinaryTreeSize(BTNode* root)
//{
//	if (root == NULL)
//	{
//		return 0;
//	}
//	size++;
//	BinaryTreeSize(root->left);
//	BinaryTreeSize(root->right);
//	return size;
//}//方法二：需要改造函数定义
//void BinaryTreeSize(BTNode* root,int* psize)
//{
//	if (root == NULL)
//	{
//		return;
//	}
//	(*psize)++;
//	BinaryTreeSize(root->left, psize);
//	BinaryTreeSize(root->right, psize);
//}//节点总数 = 1 + 左子树节点个数 + 右子树节点个数
int BinaryTreeSize(BTNode* root)
{if (root == NULL){return 0;}return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}//二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root)
{if (root == NULL){return 0;}//判断是否为叶子节点if (root->left == NULL && root->right == NULL){return 1;}//走到这里节点不为空，也不为叶子节点，继续向下递归//求左子树叶子节点个数+右子树叶子节点个数return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}//二叉树第K层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{if (root == NULL){return 0;}//节点不为空，且K=1if (k == 1){return 1;}//节点不为空，且不是第K层，继续递归左右子树，每向下递归一次K-1return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}//二叉树的深度/高度
int BinaryTreeDepth(BTNode* root)
{if (root == NULL){return 0;}int leftDep = BinaryTreeDepth(root->left);int rightDep = BinaryTreeDepth(root->right);//根节点+manx(左子树高度，右子树高度)return 1 + (leftDep > rightDep ? leftDep : rightDep);
}//二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{if (root == NULL){return NULL;}if (root->data == x){return root;}//节点不为空，且节点的值不为xBTNode* leftFind = BinaryTreeFind(root->left, x);//找到了if (leftFind){return leftFind;}BTNode* rightFind = BinaryTreeFind(root->right, x);if (rightFind){return rightFind;}return NULL;
}//二叉树销毁
void BinaryTreeDestory(BTNode** root)
{if (*root == NULL){return;}BinaryTreeDestory(&((*root)->left));BinaryTreeDestory(&((*root)->right));free(*root);*root = NULL;
}//层序遍历 --- 借助数据结构：队列
void LevelOrder(BTNode* root)
{Queue q;QueueInit(&q);//在队列中存根结点QueuePush(&q, root);while (!QueueEmpty(&q)){//取队头，打印队头BTNode* top = QueueFront(&q);printf("%c ", top->data);//出队QueuePop(&q);if (top->left){QueuePush(&q, top->left);}if (top->right){QueuePush(&q, top->right);}}QueueDesTroy(&q);
}//判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{Queue q;QueueInit(&q);//头结点入队列QueuePush(&q, root);while (!QueueEmpty(&q)){//取队头，出队头BTNode* top = QueueFront(&q);QueuePop(&q);//top取到空，直接跳出循环if (top == NULL){break;}//top不为空，将队头节点的左右孩子入队列QueuePush(&q, top->left);QueuePush(&q, top->right);}//循环判断剩下的结点是否存在非空结点while (!QueueEmpty(&q)){BTNode* top = QueueFront(&q);QueuePop(&q);if (top != NULL){//剩下结点存在非空结点，不是完全二叉树QueueDesTroy(&q);return false;}}//队列为空，也没有取到不为空的结点QueueDesTroy(&q);return true;
}

test_10_28_01.c

#include"Tree.h"//创建节点 - 节点内存储char类型的值
BTNode* buyNode(char x)
{BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));if (newnode == NULL){perror("malloc fail!");exit(1);}newnode->data = x;newnode->left = newnode->right = NULL;return newnode;
}//创建二叉树
BTNode* createTree()
{BTNode* nodeA = buyNode('A');BTNode* nodeB = buyNode('B');BTNode* nodeC = buyNode('C');BTNode* nodeD = buyNode('D');BTNode* nodeE = buyNode('E');BTNode* nodeF = buyNode('F');nodeA->left = nodeB;nodeA->right = nodeC;nodeB->left = nodeD;nodeC->left = nodeE;nodeC->right = nodeF;//nodeB->right = nodeE;//nodeC->left = nodeF;return nodeA;
}void test01()
{BTNode* root = createTree();//传根节点//PreOrder(root);//InOrder(root);//PostOrder(root);//printf("size:%d\n", BinaryTreeSize(root));//printf("size:%d\n", BinaryTreeSize(root));//int Treesize = 0;//BinaryTreeSize(root, &Treesize);//printf("size:%d\n", Treesize);//Treesize = 0;//BinaryTreeSize(root, &Treesize);//printf("size:%d\n", Treesize);//printf("size:%d\n", BinaryTreeSize(root));//printf("size:%d\n", BinaryTreeSize(root));//printf("size:%d\n", BinaryTreeSize(root));//printf("leaf size:%d\n", BinaryTreeLeafSize(root));//printf("K level Size:%d\n", BinaryTreeLevelKSize(root, 3));//printf("K level Size:%d\n", BinaryTreeLevelKSize(root, 2));//printf("K level Size:%d\n", BinaryTreeLevelKSize(root, 1));//printf("Tree Depth:%d\n", BinaryTreeDepth(root));//BTNode* find = BinaryTreeFind(root, 'F');//if (find)//{//	printf("找到了\n");//}//else {//	printf("未找到\n");//}//printf("层序遍历的结果：");//LevelOrder(root);bool isComplete = BinaryTreeComplete(root);if (isComplete){printf("是完全二叉树\n");}else {printf("不是完全二叉树\n");}BinaryTreeDestory(&root);
}int main()
{test01();return 0;
}