• 用c语言实现一个简单的链表二叉树

    前言

            hi~大家好呀，欢迎点进我的文章！❥(ゝω・✿ฺ)这篇讲的是一个如何用c语言简单实现数据结构中的一个基础二叉树的结构以及相关功能！我会把我的思路和过程展示出来，这本身也是一份学习笔记，我们一起进步吧~

     

    ---------------------------------------------------------------------------------------------------------------------------------

    目录

    前言

    一、明确一个二叉树

    1.树的结构

    2.二叉树的结构 

    二、c语言实现链表二叉树

    1.明确实现结构以及功能

    2.代码具体实现

    1结点结构struct BTNode

    2建立结点BuyNode

    3前序遍历BTPrevOrder 

    4中序遍历BTInOrder

    5后序遍历BTPostOrder

    6层序遍历BTLevelOrder

    7二叉树摧毁BTDestroy

    8根据前序新建二叉树BTCreate

    9统计结点个数BTSize

    10统计叶子结点个数BTLeafSize

    11统计第k层结点个数BTLevelKSize

    12寻找值为x的结点BTFind

    13判断是否满二叉树BTComplete

    3.综合代码

    BTNode.h

    BTNode.c

    BTNodeTest.c

    一、明确一个二叉树

    1.树的结构

            在了解二叉树之前，我们首先来介绍一下树这个数据结构：

    树是区别于线性表的另一种数据结构，是结点的有限集合。

            如上图所示，这就是一个数的结构。每一个圆圈就可以代表一个结点。这个结点里面自然就可以储存数据。我们常见文件系统（磁盘下的文件）就是这个数据结构哦~

            既然有这么一种数据结构，那么我们也会根据结点的性质来对其起名。

            就上面的图而言，圆圈均可代表结点，其中黑色的就是叶子结点。

    对树的基本认知：

    1)节点的度：一个节点含有的子树个数 (2)叶节点或者终端节点：度为0的节点为叶节点  (3)非终端节点或者分支节点：度不为0的节点 (4)双亲节点或父节点：若一个节点带有子节点则就是其的父节点 (5)孩子节点或者子节点 一个节点含有的子节点就是(6)兄弟节点 具有相同父节点(7)树的度 一棵树中最大节点的度就是(8)节点的层次： 从根开始定义起根为第一层 其子节点为第二层，依次类推 (9)双亲在同一层的节点为堂兄弟节点 (10)节点的祖先 从根到该节点所经分支上的所有节点 (11)子孙 某节点为根的子树的任意节点为该节点的子孙 ()12 由大于零棵树互不相交的集合叫森林 多棵没有交叉的树(大后期 并查集)。空树的高度就是0节点没有

    2.二叉树的结构 

            在对树有了一定认识之后，那么我们就可以来了解二叉树啦~

            根据名字就可以知道，二~即计划生育后的树--

    二叉树：一个结点的有限集合。每个结点最多有两个子树 。

            如上图，这就是三个二叉树。

            相对的，根据二叉树每层的结点顺序也就有了如下区分：

    满二叉树：每一层都是满的（最后一层全是叶节点） 每层满足 2^(k-1)次方 (k代表层数,从1开始) 节点总数就是 2^(k) - 1     

            如上图黑树。

    完全二叉树：前k-1层满的，最后一层是从左到右是连续的（即在k-1层满足度为1的最多只有一个）

    由满二叉树可以推出 高度为h的完全二叉树的节点范围是 2^(h - 1) ~ 2^(h) - 1

            如上图蓝树。

            同样的，任何一个二叉树都满足如下规则：

    设满足度为0的节点数为n1，满足度为2的节点数为n2，则有n2 = n1 + 1

    (记忆方法：三个结点的满二叉树作为记忆)

            那么，现在针对于完全二叉树，我们能否编程让这个数据结构实现储存数据并且简单建立起树的结构呢？答案是可以，建立这个结构同样的有两种方式：一个是数组，另一个就是链表。

             数组虽然是线性储存的，但是我们只需要规定插入和取出时的算法即可。（比如父结点和子结点之间的关系：parent = (child - 1) / 2（不分左右结点），leftchild = parent*2+1,rightchild = parent * 2 + 2）但是会对空间造成一定的浪费，所以我们这里实现就用链表，每个结点用两个指针用来指向左孩子和右孩子。

    二、c语言实现链表二叉树

    1.明确实现结构以及功能

            上面我们明确了一个二叉树，现在我们需要通过链表来简单实现这个数据结构。

            首先明确结构就是一个结点，一个结点里面存放着数据、指向左孩子的指针、指向右孩子的指针。

             然后通过结点的集合（即创建多个此结构的对象），手动（手动指向结点的左右孩子）或者根据前序(遍历二叉树的顺序)创造一个完全二叉树。

            黑色圆圈内就代表左右孩子指向NULL。

            结构创建完毕后就要实现具体的一些简单功能：

    1.遍历：

            根据树的特性：前序遍历、中序遍历、后序遍历、层序遍历

            前序遍历：

    先访问此结点的数据，然后访问左节点，最后访问右节点。

             如上图，数字表示访问结点数据，其中4 5 7 8....表示访问的NULL，然后返回。

    单链表的C++实现。。
    text/x-c 0星 超过10%的资源 6KB
    下载

            中序遍历：

    先访问左结点，然后访问此结点数据，最后访问右节点。

            同理。

             后序遍历：

    先访问左结点，然后访问右结点，最后访问此结点数据。

             同理。可以发现差异巨大，这些均可以通过递归进行实现，即先处理什么，在处理什么，最后处理什么的思路。

            层序遍历：

    从上到下，从左到右依次访问结点数据。

             层序遍历遵循线性表的顺序，数组容易实现，对于链表结点时可以采用数据结构中的队列（先进先出的性质）作为辅助实现。

    2.其他功能：

    新建二叉树（根据前序顺序进行构造一个树）、摧毁二叉树（将树结点每一个从堆那里申请的给回收）、结点个数、叶子结点个数、第k层结点、寻找值为x的结点。

            废话不多说，我们直接代码实现吧：

    2.代码具体实现

    1结点结构struct BTNode

            结点结构就是一个存放数据一个存放孩子的指针哦（有两个）另外，二叉树英文名为binary tree，所以就简写为BT啦：

    1. typedef char BTDataType;
    2. typedef struct BTNode
    3. {
    4. 	BTDataType x;
    5. 	struct BTNode* left;
    6. 	struct BTNode* right;
    7. }BTNode;

            （数据类型为char，为了配合之后的利用前序创建一个二叉树（会用到符号识别，比如NULL用#代替））

    2建立结点BuyNode

            首先就是自然的去堆中申请，检查是否申请到，然后将传过来的数据存入此结点，在将此结点的左右指针置为空，等待外界去连接。

    1. BTNode* BuyNode(BTDataType x)
    2. {
    3. 	BTNode* temp = (BTNode*)malloc(sizeof(BTNode));
    4. 	if (temp == NULL)
    5. 	{
    6. 		perror("BuyNode::malloc");
    7. 		exit(-1);
    8. 	}
    9. 	temp->x = x;
    10. 	temp->left = temp->right = NULL;
    11. 	return temp;
    12. }

    3前序遍历BTPrevOrder 

            根据前序遍历，首先访问此结点的数据，然后访问左结点，最后访问右结点。注意这里访问左结点不是访问左结点的数据，而是进入左结点重复上述步骤。然后进入右结点重复上述步骤。直到这两步进行完此函数栈帧就执行完毕。

            对此，程序可如下写：

    1. void BTPrevOrder(BTNode* pn)
    2. {
    3. 	if (pn == NULL)
    4. 	{
    5. 		printf("# ");
    6. 		return;
    7. 	}
    8. 	printf("%c ", pn->x);
    9. 	BTPrevOrder(pn->left);
    10. 	BTPrevOrder(pn->right);
    11. }

            可以发现，通过递归调用，进入左结点后，继续进行访问此结点数据，然后在进入左结点，直到遇到此为空，就输出#并且返回。返回的上一步就去右结点，同样也是遇到NULL就输出#并且返回。 

            具体如下二叉树进行表示：

    4中序遍历BTInOrder

            中序遍历思路和前序遍历类似，只不过顺序变了，先访问左结点，在访问此结点的数据，最后访问右结点：

    1. void BTInOrder(BTNode* pn)
    2. {
    3. 	if (pn == NULL)
    4. 	{
    5. 		printf("# ");
    6. 		return;
    7. 	}
    8. 	BTInOrder(pn->left);
    9. 	printf("%c ", pn->x);
    10. 	BTInOrder(pn->right);
    11. }

    5后序遍历BTPostOrder

            后序先访问左结点，然后访问右结点，最后访问此结点数据：

    1. void BTPostOrder(BTNode* pn)
    2. {
    3. 	if (pn == NULL)
    4. 	{
    5. 		printf("# ");
    6. 		return;
    7. 	}
    8. 	BTPostOrder(pn->left);
    9. 	BTPostOrder(pn->right);
    10. 	printf("%c ", pn->x);
    11. }

    6层序遍历BTLevelOrder

            层序遍历遵循的是从上到下，从左到右，普通的遍历的话一般只能把一边的先遍历完，比如想要推进的话通常就会将其的子结点赋给下一个要输出的结点，而不会找兄弟结点。即重点就是每次能够和兄弟结点一起成为循环。那么不妨就采用队列这个数据结构。

    1. ///
    2.  
    3. //下面定义链表结构 -- 单链表 单链表的话需要单独定义两个指针一个指向头一个指向尾，方便进行插入和出列
    4. typedef BTNode* QueueDateType;
    5. typedef struct QListNode
    6. {
    7. 	QueueDateType x;
    8. 	struct QListNode* next;//存放下一指针的
    9. }QNode;
    10.  
    11. typedef struct Queue
    12. {
    13. 	QNode* head;//存放队首
    14. 	QNode* tail;//存放队尾
    15. }Queue;
    16.  
    17. //队列初始化，让队列的头和尾指向空
    18. void QueueInit(Queue* pq)
    19. {
    20. 	assert(pq);//防止空指针引用
    21. 	pq->head = pq->tail = NULL;
    22. }
    23.  
    24. //队列摧毁 将堆内存申请的空间回收
    25. void QueueDestroy(Queue* pq)
    26. {
    27. 	assert(pq);//查看是否空指针引用
    28. 	while (pq->head)
    29. 	{
    30. 		QNode* temp = pq->head;
    31. 		pq->head = temp->next;
    32. 		free(temp);
    33. 	}
    34. 	pq->tail = NULL;
    35. }
    36.  
    37. //入队 普通单链表进行尾插
    38. void QueuePush(Queue* pq, QueueDateType x)
    39. {
    40. 	assert(pq);
    41. 	QNode* newNode = (QNode*)malloc(sizeof(QNode));
    42. 	if (newNode == NULL)
    43. 	{
    44. 		perror("QueuePush");
    45. 		exit(-1);//不正常情况退出进程
    46. 	}
    47. 	newNode->x = x;
    48. 	newNode->next = NULL;
    49. 	if (pq->head == NULL)//第一次进
    50. 	{
    51. 		pq->head = pq->tail = newNode;
    52. 	}
    53. 	else//正常入队
    54. 	{
    55. 		pq->tail->next = newNode;
    56. 		pq->tail = newNode;//保存尾元素
    57. 	}
    58. }
    59.  
    60. //判断是否存在元素
    61. bool QueueEmpty(Queue* pq)
    62. {
    63. 	assert(pq);
    64. 	return pq->head == NULL;//是空表明没有元素，返回真，否则为假
    65. }
    66. //出元素：
    67. QueueDateType QueueTop(Queue* pq)
    68. {
    69. 	assert(pq && !QueueEmpty(pq));
    70. 	return pq->head->x;
    71. }
    72. //出队 先进先出出头结点，然后将头结点更换成下一个结点
    73. void QueuePop(Queue* pq)
    74. {
    75. 	assert(pq && !QueueEmpty(pq));//判断是否空指针引用或者是否空队列
    76. 	if (pq->head == pq->tail)//只有一个元素
    77. 	{
    78. 		free(pq->head);
    79. 		pq->head = pq->tail = NULL;
    80. 	}
    81. 	else
    82. 	{
    83. 		QNode* temp = pq->head->next;
    84. 		free(pq->head);
    85. 		pq->head = temp;
    86. 	}
    87. }
    88. /
    89.  
    90.  
    91.  
    92. //层序遍历  利用队列的性质 首先进根结点，打印出此值后就出队列，如果孩子不为空就进队列，此时顺序就是左 右，之后就打印左孩子的值，然后进左右，重复上述
    93. void BTLevelOrder(BTNode* pn)
    94. {
    95. 	assert(pn);
    96. 	Queue e;
    97. 	QueueInit(&e);
    98. 	QueuePush(&e, pn);
    99. 	while (!QueueEmpty(&e))//队列没有空就打印哦
    100. 	{
    101. 		BTNode* temp = QueueTop(&e);
    102. 		printf("%c ", temp->x);
    103. 		QueuePop(&e);
    104. 		if (temp->left)
    105. 			QueuePush(&e, temp->left);
    106. 		if (temp->right)
    107. 			QueuePush(&e, temp->right);
    108. 	}
    109. 	printf("\n");
    110. 	QueueDestroy(&e);
    111. }
    二叉树的二叉链表表示与实现
    zip 5星 超过95%的资源 10KB
    下载

            如上，先是实现了队列这个数据结构 ，将储存的数据定为结点类型。根据特性，先进先出，我们现在需要保证出是按照从上到下从左到右的结点顺序，那么入队列的顺序就自然就是从上到下，从左到右。那么，每一次入的时候两个孩子只要不为空就入，下一次第一个就是左孩子，入左孩子的左右孩子，第三次就是右孩子，入右孩子的左右孩子....依次进行，就可以发现入的时候就是从上到下从左到右了。

            如下图，参照左边二叉树，右边动画演示插入：

    7二叉树摧毁BTDestroy

            既然是摧毁二叉树，那么就需要将每个结点清理调，就需要进行遍历。我这里采用后序遍历的方式，将每个结点都free调，并且需要将指针置为空。因为需要修改指针，所以需要传二级指针。

    1. void BTDestroy(BTNode** ppn)
    2. {
    3. 	assert(ppn);
    4. 	//利用后序遍历进行全盘清理
    5. 	if (*ppn == NULL)
    6. 		return;
    7. 	BTDestroy(&((*ppn)->left));//特别注意传的是指针的地址 -- 二级指针
    8. 	BTDestroy(&((*ppn)->right));
    9. 	free(*ppn);
    10. 	*ppn = NULL;
    11. }

    8根据前序新建二叉树BTCreate

            这里根据前序新建二叉树，那么只需要和前序遍历的逻辑跟着走，利用函数BuyNode进行先创建结点，然后将左结点和右结点的创建进入递归即可，遇到‘#’就返回NULL即可。需要注意的是传入的数组，外面必须传一个能累加的i值，这样递归时才能统一，当然全局变量也可，用于推进数组：

    1. BTNode* BTCreate(char* arr, int* pi)
    2. {
    3. 	assert(arr);
    4. 	if (arr[*(pi)] == '#')
    5. 	{
    6. 		(*pi)++;
    7. 		return NULL;
    8. 	}
    9.  
    10. 	BTNode* node = BuyNode(arr[(*pi)++]);
    11. 	node->left = BTCreate(arr, pi);
    12. 	node->right = BTCreate(arr, pi);
    13. 	return node;
    14. }

    9统计结点个数BTSize

            既然是统计结点个数，同样的利用递归，判断当前结点是否为NULL，如果为NULL就返回0，否则就返回其左结点递归后的个数加上右结点递归后的个数再加1。

    1. int BTSize(BTNode* pn)
    2. {
    3. 	if (pn == NULL)
    4. 	{
    5. 		return 0;
    6. 	}
    7. 	return BTSize(pn->left) + BTSize(pn->right) + 1;
    8. }

    10统计叶子结点个数BTLeafSize

            叶子结点无疑需要有条件，即其左右孩子结点必须为空，就返回1，如果为空就返回0，均不满足就递归下去，查找左结点的叶子结点个数和右结点的叶子结点个数：

    1. int BTLeafSize(BTNode* pn)
    2. {
    3. 	if (pn == NULL)
    4. 	{
    5. 		return 0;
    6. 	}
    7. 	if (pn->left == NULL && pn->right == NULL)
    8. 		return 1;
    9. 	return BTLeafSize(pn->left) + BTLeafSize(pn->right);
    10. }

    11统计第k层结点个数BTLevelKSize

            让我们寻找第k层的结点个数。我们知道我们递归到孩子结点的时候，均为下一层，那么每次递归时减去1即可，当k==1的时候，返回1，当然，如果为空就返回0，如果不等于，就返回左孩子和右孩子相加的结果：

    1. int BTLevelKSize(BTNode* pn, int k)
    2. {
    3. 	if (pn == NULL)
    4. 		return 0;
    5. 	if (k == 1)
    6. 		return 1;
    7. 	return BTLevelKSize(pn->left, k - 1) + BTLevelKSize(pn->right, k - 1);
    8. }

    12寻找值为x的结点BTFind

            利用遍历去寻找即可，前序遍历：先查看当前结点是否为该x值，是就返回此结点，否则就让左右孩子去找，接收他们的返回值，判断是否为空（当然，结点为空就返回NULL），如果有一个不为空就返回对应的，均为空就表明没有找到了，返回空即可。

    1. BTNode* BTFind(BTNode* pn, BTDataType x)
    2. {
    3. 	if (pn == NULL)
    4. 		return NULL;
    5. 	if (pn->x == x)
    6. 		return pn;
    7. 	BTNode* left = BTFind(pn->left, x);
    8. 	if (left)
    9. 		return left;
    10. 	BTNode* right = BTFind(pn->right, x);
    11. 	if (right)
    12. 		return right;
    13. 	return NULL;
    14. }

    13判断是否满二叉树BTComplete

            判断是否满二叉树的条件：该结点的左右结点是否均为空，如果有一个不为空就返回false，否则返回true，如果均不为空，就返回左结点和右结点是否均为true，均为true就表明是满二叉树，就返回true，否则就返回false。（当然，最后可以直接返回两者且的结果）

    1. bool BTComplete(BTNode* pn)
    2. {
    3. 	if (pn == NULL)
    4. 		return false;
    5. 	if (pn->left == NULL && pn->right == NULL)
    6. 		return true;
    7. 	//if (BTComplete(pn->left) && BTComplete(pn->right))
    8. 	//	return true;
    9. 	//return false;
    10. 	return BTComplete(pn->left) && BTComplete(pn->right);
    11. }

    3.综合代码

            综上，代码实现如下！

    BTNode.h

    1. #pragma once
    2. #define _CRT_SECURE_NO_WARNINGS 1
    3.  
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9.  
    10. /*<链表二叉树>   链表：  数据、左结点、右结点
    11. * 功能：新建结点 -- 手动连接
    12. *	    遍历 -- 前序、中序、后序、层序
    13. *		新建二叉树 -- 根据数组 由前序遍历进行构建
    14. *	    摧毁二叉树、结点个数、叶结点个数、第k层结点、寻找值为x的结点
    15. */
    16.  
    17. typedef char BTDataType;
    18. typedef struct BTNode
    19. {
    20. 	BTDataType x;
    21. 	struct BTNode* left;
    22. 	struct BTNode* right;
    23. }BTNode;
    24.  
    25. //建立二叉树结点
    26. BTNode* BuyNode(BTDataType x);
    27. //二叉树摧毁 -- 要修改原地址，传二级指针
    28. void BTDestroy(BTNode** ppn);
    29. //前序遍历
    30. void BTPrevOrder(BTNode* pn);
    31. //中序遍历
    32. void BTInOrder(BTNode* pn);
    33. //后序遍历
    34. void BTPostOrder(BTNode* pn);
    35. //层序遍历
    36. void BTLevelOrder(BTNode* pn);
    37. //新建二叉树 根据前序遍历进行建立： -- 字符类型
    38. BTNode* BTCreate(char* arr, int* pi);
    39. //结点个数
    40. int BTSize(BTNode* pn);
    41. //叶子结点个数
    42. int BTLeafSize(BTNode* pn);
    43. //第k层结点
    44. int BTLevelKSize(BTNode* pn, int k);
    45. //寻找值为x的结点：
    46. BTNode* BTFind(BTNode* pn, BTDataType x);
    47. //判断是否为满二叉树
    48. bool BTComplete(BTNode* pn);

    BTNode.c

    1. #include"BTNode.h"
    2.  
    3. BTNode* BuyNode(BTDataType x)
    4. {
    5. 	BTNode* temp = (BTNode*)malloc(sizeof(BTNode));
    6. 	if (temp == NULL)
    7. 	{
    8. 		perror("BuyNode::malloc");
    9. 		exit(-1);
    10. 	}
    11. 	temp->x = x;
    12. 	temp->left = temp->right = NULL;
    13. 	return temp;
    14. }
    15.  
    16. void BTDestroy(BTNode** ppn)
    17. {
    18. 	assert(ppn);
    19. 	//利用后序遍历进行全盘清理
    20. 	if (*ppn == NULL)
    21. 		return;
    22. 	BTDestroy(&((*ppn)->left));//特别注意传的是指针的地址 -- 二级指针
    23. 	BTDestroy(&((*ppn)->right));
    24. 	free(*ppn);
    25. 	*ppn = NULL;
    26. }
    27.  
    28. //前序遍历
    29. void BTPrevOrder(BTNode* pn)
    30. {
    31. 	if (pn == NULL)
    32. 	{
    33. 		printf("# ");
    34. 		return;
    35. 	}
    36. 	printf("%c ", pn->x);
    37. 	BTPrevOrder(pn->left);
    38. 	BTPrevOrder(pn->right);
    39. }
    40.  
    41. //中序遍历
    42. void BTInOrder(BTNode* pn)
    43. {
    44. 	if (pn == NULL)
    45. 	{
    46. 		printf("# ");
    47. 		return;
    48. 	}
    49. 	BTInOrder(pn->left);
    50. 	printf("%c ", pn->x);
    51. 	BTInOrder(pn->right);
    52. }
    53.  
    54. //后序遍历
    55. void BTPostOrder(BTNode* pn)
    56. {
    57. 	if (pn == NULL)
    58. 	{
    59. 		printf("# ");
    60. 		return;
    61. 	}
    62. 	BTPostOrder(pn->left);
    63. 	BTPostOrder(pn->right);
    64. 	printf("%c ", pn->x);
    65. }
    66.  
    67.  
    68.  
    69.  
    70. ///
    71.  
    72. //下面定义链表结构 -- 单链表 单链表的话需要单独定义两个指针一个指向头一个指向尾，方便进行插入和出列
    73. typedef BTNode* QueueDateType;
    74. typedef struct QListNode
    75. {
    76. 	QueueDateType x;
    77. 	struct QListNode* next;//存放下一指针的
    78. }QNode;
    79.  
    80. typedef struct Queue
    81. {
    82. 	QNode* head;//存放队首
    83. 	QNode* tail;//存放队尾
    84. }Queue;
    85.  
    86. //队列初始化，让队列的头和尾指向空
    87. void QueueInit(Queue* pq)
    88. {
    89. 	assert(pq);//防止空指针引用
    90. 	pq->head = pq->tail = NULL;
    91. }
    92.  
    93. //队列摧毁 将堆内存申请的空间回收
    94. void QueueDestroy(Queue* pq)
    95. {
    96. 	assert(pq);//查看是否空指针引用
    97. 	while (pq->head)
    98. 	{
    99. 		QNode* temp = pq->head;
    100. 		pq->head = temp->next;
    101. 		free(temp);
    102. 	}
    103. 	pq->tail = NULL;
    104. }
    105.  
    106. //入队 普通单链表进行尾插
    107. void QueuePush(Queue* pq, QueueDateType x)
    108. {
    109. 	assert(pq);
    110. 	QNode* newNode = (QNode*)malloc(sizeof(QNode));
    111. 	if (newNode == NULL)
    112. 	{
    113. 		perror("QueuePush");
    114. 		exit(-1);//不正常情况退出进程
    115. 	}
    116. 	newNode->x = x;
    117. 	newNode->next = NULL;
    118. 	if (pq->head == NULL)//第一次进
    119. 	{
    120. 		pq->head = pq->tail = newNode;
    121. 	}
    122. 	else//正常入队
    123. 	{
    124. 		pq->tail->next = newNode;
    125. 		pq->tail = newNode;//保存尾元素
    126. 	}
    127. }
    128.  
    129. //判断是否存在元素
    130. bool QueueEmpty(Queue* pq)
    131. {
    132. 	assert(pq);
    133. 	return pq->head == NULL;//是空表明没有元素，返回真，否则为假
    134. }
    135. //出元素：
    136. QueueDateType QueueTop(Queue* pq)
    137. {
    138. 	assert(pq && !QueueEmpty(pq));
    139. 	return pq->head->x;
    140. }
    141. //出队 先进先出出头结点，然后将头结点更换成下一个结点
    142. void QueuePop(Queue* pq)
    143. {
    144. 	assert(pq && !QueueEmpty(pq));//判断是否空指针引用或者是否空队列
    145. 	if (pq->head == pq->tail)//只有一个元素
    146. 	{
    147. 		free(pq->head);
    148. 		pq->head = pq->tail = NULL;
    149. 	}
    150. 	else
    151. 	{
    152. 		QNode* temp = pq->head->next;
    153. 		free(pq->head);
    154. 		pq->head = temp;
    155. 	}
    156. }
    157. /
    158.  
    159.  
    160.  
    161. //层序遍历  利用队列的性质 首先进根结点，打印出此值后就出队列，如果孩子不为空就进队列，此时顺序就是左 右，之后就打印左孩子的值，然后进左右，重复上述
    162. void BTLevelOrder(BTNode* pn)
    163. {
    164. 	assert(pn);
    165. 	Queue e;
    166. 	QueueInit(&e);
    167. 	QueuePush(&e, pn);
    168. 	while (!QueueEmpty(&e))//队列没有空就打印哦
    169. 	{
    170. 		BTNode* temp = QueueTop(&e);
    171. 		printf("%c ", temp->x);
    172. 		QueuePop(&e);
    173. 		if (temp->left)
    174. 			QueuePush(&e, temp->left);
    175. 		if (temp->right)
    176. 			QueuePush(&e, temp->right);
    177. 	}
    178. 	printf("\n");
    179. 	QueueDestroy(&e);
    180. }
    181.  
    182.  
    183. //根据字符数组  #不开 其余开结点  根据前序遍历进行创建
    184. BTNode* BTCreate(char* arr, int* pi)
    185. {
    186. 	assert(arr);
    187. 	if (arr[*(pi)] == '#')
    188. 	{
    189. 		(*pi)++;
    190. 		return NULL;
    191. 	}
    192.  
    193. 	BTNode* node = BuyNode(arr[(*pi)++]);
    194. 	node->left = BTCreate(arr, pi);
    195. 	node->right = BTCreate(arr, pi);
    196. 	return node;
    197. }
    198.  
    199. //计算结点个数
    200. int BTSize(BTNode* pn)
    201. {
    202. 	if (pn == NULL)
    203. 	{
    204. 		return 0;
    205. 	}
    206. 	return BTSize(pn->left) + BTSize(pn->right) + 1;
    207. }
    208.  
    209. //计算叶子结点个数
    210. int BTLeafSize(BTNode* pn)
    211. {
    212. 	if (pn == NULL)
    213. 	{
    214. 		return 0;
    215. 	}
    216. 	if (pn->left == NULL && pn->right == NULL)
    217. 		return 1;
    218. 	return BTLeafSize(pn->left) + BTLeafSize(pn->right);
    219. }
    220.  
    221. //第K层结点个数
    222. int BTLevelKSize(BTNode* pn, int k)
    223. {
    224. 	if (pn == NULL)
    225. 		return 0;
    226. 	if (k == 1)
    227. 		return 1;
    228. 	return BTLevelKSize(pn->left, k - 1) + BTLevelKSize(pn->right, k - 1);
    229. }
    230.  
    231. //寻找值为x的结点
    232. BTNode* BTFind(BTNode* pn, BTDataType x)
    233. {
    234. 	if (pn == NULL)
    235. 		return NULL;
    236. 	if (pn->x == x)
    237. 		return pn;
    238. 	BTNode* left = BTFind(pn->left, x);
    239. 	if (left)
    240. 		return left;
    241. 	BTNode* right = BTFind(pn->right, x);
    242. 	if (right)
    243. 		return right;
    244. 	return NULL;
    245. }
    246.  
    247.  
    248. //判断是否为完全二叉树
    249. bool BTComplete(BTNode* pn)
    250. {
    251. 	if (pn == NULL)
    252. 		return false;
    253. 	if (pn->left == NULL && pn->right == NULL)
    254. 		return true;
    255. 	//if (BTComplete(pn->left) && BTComplete(pn->right))
    256. 	//	return true;
    257. 	//return false;
    258. 	return BTComplete(pn->left) && BTComplete(pn->right);
    259. }

    BTNodeTest.c

            测试代码可以自己写哦~

    1. #include"BTNode.h"
    2.  
    3. void test()
    4. {
    5. 	//测试前序、中序、后序、层序遍历
    6. 	//BTNode* node1 = BuyNode('A');
    7. 	//BTNode* node2 = BuyNode('B');
    8. 	//BTNode* node3 = BuyNode('C');
    9. 	//BTNode* node4 = BuyNode('D');
    10. 	//node1->left = node2;
    11. 	//node1->right = node3;
    12. 	//node2->left = node4;
    13. 	//BTPrevOrder(node1);//A B D # # # C # # 
    14. 	//printf("\n");
    15. 	//BTInOrder(node1);//# D # B # A # C #
    16. 	//printf("\n");
    17. 	//BTPostOrder(node1);// # # D # B # # C A
    18. 	//printf("\n");
    19. 	//BTLevelOrder(node1);//A B C D
    20. 	//BTDestroy(&node1);
    21.  
    22. 	//测试根据前序进行创建链表二叉树
    23. 	char arr[] = "AB##c##";
    24. 	int i = 0;
    25. 	BTNode* node = BTCreate(arr, &i);
    26. 	BTPrevOrder(node);
    27. 	printf("\n");
    28. 	//测试节点数、叶子结点、第k层结点、查找结点
    29. 	printf("结点数：%d\n", BTSize(node));
    30. 	printf("叶子结点数：%d\n", BTLeafSize(node));
    31. 	printf("第1层结点数：%d\n", BTLevelKSize(node, 1));
    32. 	printf("第2层结点数：%d\n", BTLevelKSize(node, 2));
    33. 	//printf("第3层结点数：%d\n", BTLevelKSize(node, 3));
    34. 	printf("寻找A：%c\n", BTFind(node, 'A')->x);
    35. 	if (BTComplete(node))
    36. 		printf("满二叉树\n");
    37. 	else
    38. 		printf("完全二叉树\n");
    39. 	BTDestroy(&node);
    40. }
    41.  
    42. int main()
    43. {
    44. 	test();
    45. 	return 0;
    46. }

            好啦~以上就是C语言实现简单的链式二叉树啦，欢迎补充哦~( • ̀ω•́ )✧(〃'▽'〃)

  • 相关阅读:
    【Linux】服务器恶意登录记录及解决方案
    【附源码】计算机毕业设计JAVA智慧养老院管理系统
    （十五）51单片机——呼吸灯与直流电机调速（PWM）
    1373. 二叉搜索子树的最大键值和
    spring boot 中使用minio
    MySQL最新2023年面试题及答案，汇总版(2)【MySQL最新2023年面试题及答案，汇总版-第三十二刊】
    【PTA题目】6-19 使用函数输出指定范围内的Fibonacci数 分数 20
    采用PHP开发的一套（项目源码）医疗安全（不良）事件报告系统源码：统计分析，持续整改，完成闭环管理
    2022-08-01 C++并发编程（四）
    【C++】红黑树的模拟实现
  • 原文地址：https://blog.csdn.net/weixin_61508423/article/details/126242059