• 【数据结构初阶】八、非线性表里的二叉树（二叉树的实现 -- C语言链式结构）

    =========================================================================

    相关代码gitee自取：

    C语言学习日记: 加油努力 (gitee.com)

     =========================================================================

    接上期：

    【数据结构初阶】七、非线性表里的二叉树（堆的实现 -- C语言顺序结构）-CSDN博客

     =========================================================================

                         

    回顾

    二叉树的概念及结构：

                     

    二叉树的概念

    一棵二叉树是节点的一个有限集合，该集合满足以下条件：

    • 或者为空
    • 或者由一个根节点加上两棵别称为左子树和右子树的二叉树组成

                    

    二叉树的结构

    • 二叉树不存在度大于2的节点
      （所以节点的度可能是 0 即空树，也可能是 1 或 2 ）
                         
    • 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
                        
    • 这次使用C语言链式结构实现二叉树，
      要会把二叉树分为 根、左子树 和 右子树 ，
      把 左子树（右子树）看成一个新的二叉树，再把其分为 根、左子树 和 右子树 ，
      依次分类下去……
    图示：

                    

    注意

    对于任意二叉树，都是由以下几种情况复合而成：

                         

                        

                        

    二叉树的存储结构（补充）

                     

    二叉树一般可以使用两种结构存储，
    一种顺序结构，一种链式结构

                  

    链式结构

    • 二叉树的链式存储结构，是指用链表来表示一棵二叉树，
      即用链来表示元素的逻辑关系
                  
    • 通常的方法是：链表中每个节点由三个域组成，数据域和左右指针域，
      左右指针分别用来给出该节点左孩子和右孩子所在的链节点的存储地址 
                 
    • 链式结构又分为二叉链和三叉链，
      初阶数据结构一般都是二叉链，高阶数据结构如红黑树等会用到三叉链
    图示：

             

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                 

    二叉树的遍历

    递归结构遍历

                       

    二叉树遍历(Traversal)是按照某种特定的规则，
    依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。
    访问节点所做的操作依赖于具体的应用问题。
    遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
                           

    • 引入一个概念 -- 深度优先遍历（DFS）
      简单理解就是从某个位置开始遍历，往“深处”遍历到无路可退再往回遍历，
      严格来说，在深度优先遍历时是先访问再往“深处”走，一般配合递归使用
      （这里前序递归遍历是最符合深度优先遍历的）
                           
    • 有三种递归遍历方式：前序（先序）/  中序  /  后序 
      如果按照递归的逻辑来说，这三种递归遍历方式都算是一种深度优先遍历，
      它们都是往“深处”遍历，只是各自访问节点值的时机不一样

                          

    前序(先序) / 中序 / 后序 的递归结构遍历

    • 前序(先序)遍历(Preorder Traversal)——访问根节点的操作发生在遍历其左右子树之前
      [即先访问根节点，再访问左子树，最后访问右子树]
                    
    • 中序遍历(Inorder Traversal)——访问根节点的操作发生在遍历其左右子树之中（间）
      [即先访问左子树，再访问根节点，最后访问右子树]
                   
    • 后序遍历(Postorder Traversal)——访问根节点的操作发生在遍历其左右子树之后
      [即先访问左子树，再访问右子树，最后访问根节点]
                        
    • 因为我们要不断的把二叉树分为 根、左子树 和 右子树 ，
      所以被访问的节点必是某子树的根，
      于是有：
      N（Node）--  根节点
      L（Left subtree）--  根的左子树
      R（Right subtree）--  根的右子树
      再安照上面的 前序(先序) / 中序 / 后序 的递归结构遍历，又有：
      NLR -- 先根(序)遍历       ；     LNR -- 中跟(序)遍历       ；     LRN -- 后根(序)遍历
    前序(先序)遍历图示：

    中序遍历图示：

    后序遍历图示：

                         

                         

                        

    层序遍历

                       

    • 除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历
                             
    • 设二叉树的根节点所在层数为第 1 层，层序遍历就是从所在二叉树的根节点出发，
      首先访问第一层的树根节点，
      然后访问左到右访问第 2 层上的节点，接着是第三层的节点
      以此类推，自上而下，自左至右逐层访问树的节点的过程就是层序遍历
                        
    • 再引入一个概念 -- 广度优先遍历（BFS）
      简单理解就是从当前“层”开始，一层一层进行遍历，和这里的层序遍历相似，
      因为队列有“先进先出”的特点，所以进行广度优先遍历时常由队列进行配合
    层序遍历图示：

             

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                 

    链式二叉树的实现

    （详细解释在图片的注释中，代码分文件放下一标题处）

                                 

    实现具体功能前的准备工作

    • 在链式二叉树头文件中包含之后所需头文件
                             
    • 定义链式二叉树节点将要存储的值的类型
                          
    • 创建链式二叉树节点类型（结构体）--  BTNode（重命名后）
                              
    • 因为之后要借助队列实现层序遍历，
      所以要将之前写的队列头文件和队列函数实现文件复制一份放入指定文件夹，
                                
    • 在链式二叉树头文件BTNode类型下方包含复制的队列头文件，
      （这样复制的队列头文件展开后才能找到BTNode类型并使用它）
      在复制的队列头文件中也包含链式二叉树头文件
                                
    • 利用队列对链式二叉树进行层序遍历时，要将链式二叉树节点指针存放在队列中，
      所以要将队列中数据域存储的数据类型改为      链式二叉树节点指针类型 -- BTNode*
    图示：

                

                

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

                

    BuyNode函数 -- 创建链式二叉树节点并对其初始化

    • 开辟动态空间 并 检查空间是否开辟成功
                             
    • 将要放入节点的值x放入节点，
      将节点的左右指针初始化为NULL
                          
    • 返回开辟的节点地址
    图示：

                

                

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

                

    PrevOrder函数 -- 前序（先序）遍历函数

    • 递归遍历到空指针NULL的话，打印当前为空节点，再返回到上层递归
                             
    • 进行前序遍历：
      先访问根节点，再访问左子树，最后访问右子树
    图示：

    （配合这个图如果还是不能理解的话，可以看下TreeSize函数后面的递归步骤图了解递归）

                

                

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

                

    InOrder函数 -- 中序遍历函数

    • 递归遍历到空指针NULL的话，打印当前为空节点，再返回到上层递归
                             
    • 进行中序遍历：
      先访问左子树，再访问根节点，最后访问右子树
    图示：

                

                

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

                

    PostOrder函数 -- 后序遍历函数

    • 递归遍历到空指针NULL的话，打印当前为空节点，再返回到上层递归
                             
    • 进行后序遍历：
      先访问左子树，再访问右子树，最后访问根节点
    图示：

                

                

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

                

    TreeSize函数 -- 计算链式二叉树中的节点个数

    • 使用三目操作符，如果根节点为空返回0（个节点），
      如果不为空则返回 TreeSize(root->left) + TreeSize(root->right) + 1
      即 左子树节点的个数 + 右子树节点的个数 + 1（根节点） --  后序遍历
    图示：

    该函数递归步骤图：

                

                

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

                

    TreeLeafSize函数 -- 计算链式二叉树中的叶子节点个数

    • 先判断当前节点是不是空节点（是不是空树），是的话返回0（个叶子节点）
                             
    • 如果(递归后)当前节点的 左子树(左孩子) 和 右子树(右孩子) 都为空，
      说明当前节点为叶子节点，返回1（个叶子节点）
                          
    • 如果(递归后)当前节点为分支节点（非空树非叶子）,
      使用递归返回其左子树和右子树的叶子节点个数
    图示：

    该函数递归步骤图：

                

                

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

                

    TreeKLevel函数 -- 计算链式二叉树中第k层的节点个数

    • 链式二叉树层数默认从第1层开始（根节点所在层数）
      assert断言接收的要求链式二叉树的层数应大于0
                             
    • （递归时）遇到空节点就返回上一层递归，返回0（个节点）
                          
    • 到达目标层数后如果节点不为空，返回1（个当层节点）
                              
    • 运用“相对层数”：
      当前树的第k层 = 左子树的第k-1层 + 右子树的第k-1层
      进行递归遍历并统计第k层的节点个数
    图示：

    该函数递归步骤图：

                

                

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

                

    TreeDestory函数 -- 对链式二叉树类型进行销毁

    • 递归遍历销毁链式二叉树时，
      如果遇到 空树 或 递归到叶子节点的“左右NULL节点”，
      则返回结束函数 或 返回上层递归
                             
    • 使用后序递归遍历销毁链式二叉树，
      先遍历销毁当前左子树，再遍历销毁当前右子树，最后销毁当前节点
      （置空操作放在调用该函数后手动进行）
    图示：

    该函数递归步骤图：

                

                

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

                

    TreeFind函数 -- 在链式二叉树中查找值为x的节点

    • 递归遍历对链式二叉树中节点进行查找时，
      如果遇到 空树 或 递归到叶子节点的“左右NULL节点”，
      则返回结束函数 或 返回上层递归
                             
    • 如果递归遍历过程中找到对应节点了，就返回该节点
                          
    • 为了防止找到对应节点后递归还未结束继续查找，
      要创建一个链式二叉树节点类型指针变量（ret），存放递归时的返回值
                
    • 先使用递归遍历当前左子树进行查找，左子树查找完后检查ret情况看是否已经找到
      未找到的话再对当前右子树进行相同操作，如果都未找到则返回空NULL
    图示：

    该函数递归步骤图：

                

                

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

                

    LevelOrder函数 -- 对链式二叉树进行层序遍历

    • 先创建一个队列类型，并对其进行初始化，
      再将链式二叉树结点指针放入队列中
                             
    • 使用while循环进行层序遍历
                      
    • （在while循环中：）
      先创建一个节点类型指针变量front存放队列中的当前节点地址，
      再通过变量front打印当前节点值
                      
    • （在while循环中：）
      然后再分别将当前节点的左右孩子录入队列中，
      最后执行出队操作，出队已打印的当前节点值，
      这样一遍循环下来就遍历了一个节点并从左往右存储其两个子节点
                          
    • 层序遍历完成后进行换行并销毁队列
    图示：

                

                

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

                

    TreeComplete函数 -- 判断该链式二叉树是不是完全二叉树

    • 先创建一个队列类型，并对其进行初始化，
      再将链式二叉树结点指针放入队列中
                             
    • 使用while循环进行层序遍历：
      先创建一个节点类型指针变量front存放队列中的当前节点地址，
      再判断当前节点是不是空节点，是就终止循环，
      然后再分别将当前节点的左右孩子录入队列中，
      最后执行出队操作，出队已判断的当前节点值
                          
    • 再使用一个while循环继续进行遍历：
      先创建一个节点类型指针变量front存放队列中的当前节点地址，
      再对上个while循环中找到的空节点进行出队，
      这时如果队列之后如果还有非空节点，
      说明该链式二叉树不是连续的，不是完全二叉树，返回false
                              
    • 如果第二个while循环能够顺利循环结束，
      说明该链式二叉树的非空节点是连续的，是完全二叉树，返回true
    图示：

                

                

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

                

    TreeHeight函数 -- 计算当前链式二叉树的高度

    • 先判断当前节点是不是空节点，是的话返回0（层）
                             
    • 使用递归分别计算左右子树的高度并记录，再返回树的高度
                          
    • 再使用三目操作符判断出较高树并返回树的高度
      （树的高度 = 左右子树中较高树的高度 + 1）
    图示：

                

                

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

                

    总体测试：

             

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                 

    对应代码

    BinaryTree.h

    1. #pragma once
    2.  
    3. //包含之后所需的头文件：
    4. #include 
    5. #include 
    6. #include 
    7.  
    8.  
    9. //二叉树的增删查改操作并不重要，应该重点了解二叉树的结构
    10. // 为后面了解高阶数据结构做铺垫
    11. //（之后高阶数据结构的搜索二叉树、AVL和红黑树才是专业的）
    12.  
    13. //指定二叉树节点存储数据的类型：
    14. typedef int BTDataType;
    15.  
    16. //创建二叉树节点类型：
    17. typedef struct BinaryTreeNode
    18. {
    19. 	//左指针：指向该节点的左孩子
    20. 	struct BinaryTreeNode* left;
    21.  
    22. 	//该节点存储的值：
    23. 	BTDataType val;
    24.  
    25. 	//右指针：指向该节点的右孩子
    26. 	struct BinaryTreeNode* right;
    27.  
    28. }BTNode; //从命名为BTNode
    29.  
    30. //包含之前写的队列头文件
    31. //（层序遍历需要用到队列）
    32. #include "Queue_BT.h"
    33. //（要包含在二叉树节点类型BTNode下方）
    34. //（这样队列头文件展开后才能
    35. //找到要存储的链式二叉树节点类型）
    36.  
    37.  
    38. //创建节点函数 -- 创建链式二叉树节点并对其初始化
    39. //接收要放入节点中的值（x）
    40. BTNode* BuyNode(int x);
    41.  
    42.  
    43. //递归结构遍历 -- 前序（先序）遍历函数
    44. //先访问根节点 - 再访问左子树 - 最后访问右子树
    45. //接收二叉树根节点地址（root）
    46. void PrevOrder(BTNode* root);
    47.  
    48.  
    49. //递归结构遍历 -- 中序遍历函数
    50. //先访问左子树 - 再访问根节点 - 最后访问右子树
    51. //接收二叉树根节点地址（root）
    52. void InOrder(BTNode* root);
    53.  
    54.  
    55. //递归结构遍历 -- 后序遍历函数
    56. //先访问左子树 - 再访问右子树 - 最后访问根节点
    57. //接收二叉树根节点地址（root）
    58. void PostOrder(BTNode* root);
    59.  
    60.  
    61. //节点数函数 -- 计算二叉树中的节点个数
    62. //接收二叉树根节点地址（root）
    63. int TreeSize(BTNode* root);
    64.  
    65.  
    66. //叶子节点数函数 -- 计算二叉树中的叶子节点个数
    67. //接收二叉树根节点地址（root）
    68. int TreeLeafSize(BTNode* root);
    69.  
    70.  
    71. //第k层节点数函数 -- 计算二叉树中第k层的节点个数
    72. //接收二叉树根节点地址（root）和层数（k）
    73. int TreeKLevel(BTNode* root, int k);
    74.  
    75.  
    76. //二叉树销毁函数 -- 对二叉树类型进行销毁
    77. //接收二叉树根节点地址（root）
    78. void TreeDestory(BTNode* root);
    79.  
    80.  
    81. //查找指定节点值函数 -- 在二叉树中查找值为x的节点
    82. //接收二叉树根节点地址（root）和 要查找的节点值（x）
    83. BTNode* TreeFind(BTNode* root, BTDataType x);
    84.  
    85.  
    86. //层序遍历函数 -- 对二叉树进行层序遍历
    87. //接收二叉树根节点地址（root）
    88. void LevelOrder(BTNode* root);
    89.  
    90.  
    91. //判断完全二叉树函数 -- 
    92. //判断该树是不是完全二叉树
    93. //接收二叉树根节点地址（root）
    94. int TreeComplete(BTNode* root);
    95.  
    96.  
    97. //计算高度函数 -- 计算当前链式二叉树的高度
    98. //接收二叉树根节点地址（root）
    99. int TreeHeight(BTNode* root);

                

                

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

                

    Queue_BT.h

    1. #pragma once
    2.  
    3. //包含之后需要的头文件：
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. 	//包含链式二叉树头文件：
    10. #include "BinaryTree.h"
    11.  
    12.  
    13. //以链表（链式结构）实现队列：
    14. //双向+循环 的链表可以解决找尾结点的问题，
    15. //定义一个尾指针也可以解决该问题，
    16. //哨兵位 可以解决二级指针的问题，
    17. //且尾插时可以少一层判断，但还有方法可以解决
    18.  
    19.  
    20. //定义队列(链式结构)中数据域存储的数据类型：
    21. typedef BTNode* QDataType;
    22. //因为要将队列应用到存储链式二叉树节点指针上
    23. //（直接存储其节点太费空间，所以存储其节点指针）
    24. //所以要把队列存储的数据类型改掉
    25. //改为和二叉树节点指针一致 -- BTNode*
    26.  
    27. //定义队列(链式结构)结点类型：
    28. typedef struct QueueNode
    29. {
    30. 	//队列指针域：
    31. 	struct QueueNode* next;
    32.  
    33. 	//队列数据域：
    34. 	QDataType data;
    35.  
    36. }QNode; //将类型重命名为Qnode
    37.  
    38.  
    39. //定义队列类型：
    40. typedef struct Queue
    41. {
    42. 	//因为用链表尾插实现入队，
    43. 	//用链表头删实现出队，
    44. 	//那么就需要头结点和尾结点的指针，
    45. 	//所以可以直接将这两个指针封装为一个类型，
    46. 	//队列类型：
    47.  
    48. 	//头结点指针：
    49. 	QNode* head;
    50.  
    51. 	//尾结点指针：
    52. 	QNode* tail;
    53.  
    54. 	//记录队列结点(元素)个数：
    55. 	int size; 
    56.  
    57. 	//这样之后在出队和入队操作时，
    58. 	//就不需要用到二级指针，
    59. 	//直接接收这个结构体指针，
    60. 	//通过结构体指针运用结构体里的头尾结点指针，
    61. 	//再用头尾结点指针定义头尾结点
    62. 	//来实现 二级指针、带哨兵位头结点 和 返回值 的作用
    63. 	//所以现在已知的通过指针定义结点的方法就有4种：
    64. 	//		1. 结构体包含结点指针
    65. 	//		2. 二级指针调用结点指针
    66. 	//		3. 哨兵位头结点指针域next指向结点地址
    67. 	//		4. 返回值返回改变的结点指针
    68.  
    69. }Que; //重命名为Que
    70.  
    71.  
    72. //队列初始化函数 -- 将队列进行初始化
    73. //接收队列类型指针(包含链表头尾结点) 
    74. void QueueInit(Que* pq);
    75.  
    76. //队列销毁函数 -- 将队列销毁
    77. //接收队列类型指针(包含链表头尾结点) 
    78. void QueueDestroy(Que* pq);
    79.  
    80. //队列入队函数 -- 用链表的尾插操作实现入队
    81. //接收队列类型指针(包含链表头尾结点) 、尾插值
    82. void QueuePush(Que* pq, QDataType x);
    83.  
    84. //队列出队函数 -- 用链表的头删操作实现出队
    85. //接收队列类型指针(包含链表头尾结点) 
    86. void QueuePop(Que* pq);
    87.  
    88. //队头函数 -- 返回队头结点的数据域数据
    89. //接收队列类型指针(包含链表头尾结点) 
    90. QDataType QueueFront(Que* pq);
    91.  
    92. //队尾函数 -- 返回队尾结点的数据域数据
    93. //接收队列类型指针(包含链表头尾结点) 
    94. QDataType QueueBack(Que* pq);
    95.  
    96. //判空函数 -- 判断队列是否为空
    97. //接收队列类型指针(包含链表头尾结点) 
    98. bool QueueEmpty(Que* pq);
    99.  
    100. //队列大小函数 -- 判断队列结点(元素)个数
    101. //接收队列类型指针(包含链表头尾结点) 
    102. int QueueSize(Que* pq);

                

                

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

                

    BinaryTree.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. //包含二叉树头文件：
    4. #include "BinaryTree.h"
    5.  
    6.  
    7. //创建节点函数 -- 创建链式二叉树节点并对其初始化
    8. //接收要放入节点中的值（x）
    9. BTNode* BuyNode(int x)
    10. {
    11. 	//开辟动态空间：
    12. 	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    13. 	//检查是否开辟成功：
    14. 	if (node == NULL)
    15. 	{
    16. 		//开辟失败则打印错误信息：
    17. 		perror("malloc fail");
    18. 		//终止程序：
    19. 		exit(-1);
    20. 	}
    21.  
    22. 	//将要放入节点的值x放入节点：
    23. 	node->val = x;
    24. 	//将节点的左右指针初始化为NULL：
    25. 	node->left = NULL;
    26. 	node->right = NULL;
    27.  
    28. 	//返回开辟的节点地址：
    29. 	return node;
    30. }
    31.  
    32.  
    33.  
    34. //递归结构遍历 -- 前序（先序）遍历
    35. //先访问根节点 - 再访问左子树 - 最后访问右子树
    36. //接收二叉树根节点地址（root）
    37. void PrevOrder(BTNode* root)
    38. {
    39. 	//递归遍历到空指针NULL（或空树）：
    40. 	if (root == NULL)
    41. 	{
    42. 		//打印当前为空节点：
    43. 		printf("NULL  ");
    44.  
    45. 		//返回结束当前递归：
    46. 		return;
    47. 	}
    48.  
    49. 	//进行前序遍历：
    50. 	//先访问根节点 -- 打印当前节点的值：
    51. 	printf("%d  ", root->val);
    52.  
    53. 	//再访问左子树 -- 使用递归打印左子树：
    54. 	PrevOrder(root->left);
    55.  
    56. 	//最后访问右子树 -- 使用递归打印右子树：
    57. 	PrevOrder(root->right);
    58. }
    59.  
    60.  
    61.  
    62. //递归结构遍历 -- 中序遍历
    63. //先访问左子树 - 再访问根节点 - 最后访问右子树
    64. //接收二叉树根节点地址（root）
    65. void InOrder(BTNode* root)
    66. {
    67. 	//递归遍历到空指针NULL：
    68. 	if (root == NULL)
    69. 	{
    70. 		//打印当前为空节点：
    71. 		printf("NULL  ");
    72.  
    73. 		//返回结束当前递归：
    74. 		return;
    75. 	}
    76.  
    77. 	//进行中序遍历：
    78. 	//先访问左子树 -- 使用递归打印左子树：
    79. 	InOrder(root->left);
    80.  
    81. 	//再访问根节点 -- 打印当前节点的值：
    82. 	printf("%d  ", root->val);
    83.  
    84. 	//最后访问右子树 -- 使用递归打印右子树：
    85. 	InOrder(root->right);
    86. }
    87.  
    88.  
    89.  
    90. //递归结构遍历 -- 后序遍历
    91. //先访问左子树 - 再访问右子树 - 最后访问根节点
    92. //接收二叉树根节点地址（root）
    93. void PostOrder(BTNode* root)
    94. {
    95. 	//递归遍历到空指针NULL：
    96. 	if (root == NULL)
    97. 	{
    98. 		//打印当前为空节点：
    99. 		printf("NULL  ");
    100.  
    101. 		//返回结束当前递归：
    102. 		return;
    103. 	}
    104.  
    105. 	//进行后序遍历：
    106. 	//先访问左子树 -- 使用递归打印左子树：
    107. 	PostOrder(root->left);
    108.  
    109. 	//再访问右子树 -- 使用递归打印右子树：
    110. 	PostOrder(root->right);
    111.  
    112. 	//最后访问根节点 -- 打印当前节点的值：
    113. 	printf("%d  ", root->val);
    114. }
    115.  
    116.  
    117.  
    118. //节点数函数 -- 计算二叉树中的节点个数
    119. //接收二叉树根节点地址（root）
    120. int TreeSize(BTNode* root)
    121. {
    122. 	//第二种方法：“分治”思想
    123. 	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
    124. 	//使用三目操作符，如果根节点为空返回0（个节点）
    125. 	//如果不为空则返回 TreeSize(root->left) + TreeSize(root->right) + 1
    126. 	//即 左子树节点的个数 + 右子树节点的个数 + 1（根节点） --  后序遍历
    127. }
    128.  
    129.  
    130.  
    131. //第一种方法：递归遍历统计二叉树节点个数
    132. /*
    133. //节点数函数 -- 计算二叉树中的节点个数
    134. //接收二叉树根节点地址（root）
    135. int TreeSize(BTNode* root)
    136. {
    137. 	//递归时每递归一次就会创建一次栈帧，
    138. 	//如果有初始化普通变量，每递归一次就会初始化一次，
    139. 	//所以要赋予普通变量常属性，使其成为静态成员变量，
    140. 	//局部的静态成员变量只会被初始化一次：
    141. 	static int size = 0;
    142. 	//但是这样该函数就只能调用一次，因为调用一次后，
    143. 	//该变量不会再初始化为0，直到程序结束才被销毁
    145. 	//那么可以把size定义为全局变量，
    146. 	//在主函数调用该函数前就要先将size初始化为0
    149. 	if (root == NULL)
    150. 		//如果根节点为空：
    151. 	{
    152. 		return 0; //返回0表0个节点
    153. 	}
    154. 	else
    155. 	{
    156. 		++size; //root不为空则个数++
    157. 	}
    159. 	//使用递归遍历计算（类似前序遍历）：
    160. 	TreeSize(root->left); //先遍历左子树
    161. 	TreeSize(root->right); //再遍历右子树
    163. 	//返回二叉树中节点个数：
    164. 	return size;
    165. 	
    166. }
    167. */
    168.  
    169.  
    170.  
    171.  
    172. //叶子节点数函数 -- 计算二叉树中的叶子节点个数
    173. //接收二叉树根节点地址（root）
    174. int TreeLeafSize(BTNode* root)
    175. {
    176. 	if (root == NULL)
    177. 		//如果当前根节点为空：
    178. 		//（当前为空树）
    179. 	{
    180. 		//返回0 -- 无叶子节点：
    181. 		return 0;
    182. 	}
    183.  
    184. 	if (root->left == NULL && root->right == NULL)
    185. 		//如果当前节点的左子树(左孩子)和右子树(右孩子)都为空：
    186. 	{
    187. 		//说明当前节点为叶子节点，左右指针都指向NULL：
    188. 		return 1; //返回1
    189. 	}
    190.  
    191. 	//能执行到这说明当前节点为非空树非叶子节点 -- 分支节点
    192.  
    193. 	//如果递归后当前节点为分支节点（非空树非叶子）,
    194. 	//使用递归返回其左子树和右子树的叶子节点个数：
    195. 	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
    196. }
    197.  
    198.  
    199.  
    200.  
    201. //第k层节点数函数 -- 计算二叉树中第k层的节点个数
    202. //接收二叉树根节点地址（root）和层数（k）
    203. int TreeKLevel(BTNode* root, int k)
    204. {
    205. 	//层数默认从第1层开始（根节点所在层数）
    206. 	//assert断言二叉树的层数大于0:
    207. 	assert(k > 0);
    208.  
    209. 	//（递归时）遍历过程遇到空节点：
    210. 	if (root == NULL)
    211. 	{
    212. 		//已经遇到空节点就返回上一层递归
    213. 		return 0;
    214. 	}
    215.  
    216. 	//到达目标层数后如果节点不为空：
    217. 	if (k == 1)
    218. 	{
    219. 		//返回1个当层节点：
    220. 		return 1;
    221. 	}
    222.  
    223. 	//需知：“相对层数”
    224. 	//我们说的第k层是以根节点（第1层）为准的
    225. 	// "第一层的第三层 等于 第二层的第二层 等于 第三层的第一层"
    226. 	// 爷爷找孙子，可以先找孙子的爸爸，再让爸爸找儿子（爷爷的孙子）
    227. 	//所以有：当前树的第k层 = 左子树的第k-1层 + 右子树的第k-1层 
    228. 	//					（递归的降级）
    229. 	
    230. 	//当前树的第k层 = 左子树的第k-1层 + 右子树的第k-1层 ：
    231. 	return TreeKLevel(root->left, k - 1)
    232. 		 + TreeKLevel(root->right, k - 1);
    233. }
    234.  
    235.  
    236.  
    237. //二叉树销毁函数 -- 对二叉树类型进行销毁
    238. //接收二叉树根节点地址（root）
    239. void TreeDestory(BTNode* root)
    240. {
    241. 	//分三部分进行销毁：
    242. 	//当前节点、左子树、右子树
    243. 	
    244. 	//使用后序销毁二叉树：
    245. 	//最后才销毁根节点，
    246. 	//防止先销毁根节点后找不到左右子树，
    247. 	//导致最后不能销毁左右1子树
    248.  
    249. 	if (root == NULL)
    250. 		//如果遇到空树，
    251. 		//或者递归到叶子节点的“左右NULL节点”：
    252. 	{
    253. 		//直接返回：
    254. 		return;
    255. 	}
    256. 	
    257. 	//使用后序遍历：
    258. 	//先遍历销毁当前左子树：
    259. 	TreeDestory(root->left);
    260. 	//再遍历销毁当前右子树：
    261. 	TreeDestory(root->right);
    262. 	//最后销毁当前节点：
    263. 	free(root);
    264.  
    265. 	//置空操作放在调用该函数后手动进行
    266. }
    267.  
    268.  
    269.  
    270. //查找指定节点值函数 -- 在二叉树中查找值为x的节点
    271. //接收二叉树根节点地址（root）和 要查找的节点值（x）
    272. BTNode* TreeFind(BTNode* root, BTDataType x)
    273. {
    274. 	//如果是空树（或“左右NULL子树”）：
    275. 	if (root == NULL)
    276. 	{
    277. 		//那就不用找了，直接返回空：
    278. 		return NULL;
    279. 	}
    280. 	
    281. 	//递归过程中找到对应节点了：
    282. 	if (root->val == x)
    283. 	{
    284. 		//返回该节点指针：
    285. 		return root;
    286. 	}
    287.  
    288. 	//为了防止找到后往回递归又返回
    289. 	//覆盖掉了找到的节点指针，
    290. 	//所以要创建一个变量存储找到的节点指针
    291. 	//方便最终返回该指针：
    292. 	
    293. 	//创建二叉树节点类型指针变量：
    294. 	BTNode* ret = NULL;
    295.  
    296. 	//进行递归并用变量ret存储：
    297. 	//（如果在左子树中找到）
    298. 	ret = TreeFind(root->left, x);
    299. 	//如果找到了就不用再递归遍历右子树了，
    300. 	//判断并返回在左子树中找到的对应节点地址：
    301. 	if (ret != NULL)
    302. 		//ret不为空说明已经在左子树中找到了对应节点：
    303. 	{
    304. 		//进行返回，不在进行下面的右子树遍历：
    305. 		return ret;
    306. 	}
    307. 	
    308. 	//执行到这里说明左子树中未找到相应节点，
    309. 	//需再遍历右子树进行查找：
    310. 	ret = TreeFind(root->right, x);
    311. 	//如果在右边找到了：
    312. 	if (ret != NULL)
    313. 		//此时ret不为空，
    314. 		//说明在右子树中找到了对应节点：
    315. 	{
    316. 		//返回找到的节点地址：
    317. 		return ret;
    318. 	}
    319.  
    320. 	//如果能执行到这，说明二叉树中没有该节点：
    321. 	return NULL; //返回空
    322. }
    323.  
    324.  
    325.  
    326. //层序遍历函数 -- 对二叉树进行层序遍历
    327. //接收二叉树根节点地址（root）
    328. void LevelOrder(BTNode* root)
    329. {
    330. 	//使用 队列 存储二叉树：“上一层带下一层”
    331. 	//（从上到下、从左到右存储二叉树）
    332.  
    333. 	//先创建一个队列类型：
    334. 	Que q;
    335. 		
    336. 	//对队列进行初始化：
    337. 	QueueInit(&q);
    338.  
    339. 	//先将二叉树根节点root放入队列中：
    340. 	if (root != NULL)
    341. 		//二叉树根节点不为空才能放入队列：
    342. 	{
    343. 		//使用队列入队函数QueuePush将根节点（指针）录入：
    344. 		QueuePush(&q, root);
    345. 	}
    346. 	
    347. 	//之后再使用while循环，进行层序遍历：
    348. 	while (QueueEmpty(&q) != true)
    349. 		//只要当前队列不为空（队列中还有节点指针）就继续层序遍历：
    350. 	{
    351. 		//使用队列的队头函数QueueFront获取队头的节点指针：
    352. 		BTNode* front = QueueFront(&q);
    353.  
    354. 		//打印当前队头节点值：
    355. 		printf("%d ", front->val);
    356. 		
    357. 		//先录入当前节点左孩子：
    358. 		//如果当前节点左孩子不为空，就将其左孩子录入队列：
    359. 		if (front->left != NULL)
    360. 		{
    361. 			//使用队列入队函数QueuePush将当前左孩子录入队列：
    362. 			QueuePush(&q, front->left);
    363. 		}
    364.  
    365. 		//再录入当前节点右孩子：
    366. 		//如果当前节点右孩子不为空，就将其右孩子录入队列：
    367. 		if (front->right != NULL)
    368. 		{
    369. 			//使用队列入队函数QueuePush将当前右孩子录入队列：
    370. 			QueuePush(&q, front->right);
    371. 		}
    372.  
    373. 		//打印当前节点值 且 录入新左后节点指针 后，
    374. 		//将当前节点出队(队列出队函数QueuePop)，
    375. 		//对下个队头二叉树节点指针进行相同操作：
    376. 		QueuePop(&q);
    377.  
    378. 		//（完成“上一层带下一层”，从上到下、从左到右存储二叉树）
    379. 	}
    380.  
    381. 	//层序遍历完成后换行：
    382. 	printf("\n");
    383.  
    384. 	//使用队列对二叉树遍历完成后，销毁队列：
    385. 	QueueDestroy(&q);
    386. }
    387.  
    388.  
    389.  
    390. //判断完全二叉树函数 -- 判断该树是不是完全二叉树
    391. //接收二叉树根节点地址（root）
    392. int TreeComplete(BTNode* root)
    393. {
    394. 	/*
    395. 	思路：利用层序遍历的特征进行判断
    396. 	遍历时如果有空节点，将空节点也进行遍历，
    397. 	看最终空节点的分布情况就能判断是不是完全二叉树
    398. 	1、遍历时如果非空节点是连续的，就是完全二叉树
    399. 	2、遍历时如果非空节点不连续，遍历时中间右出现空节点，就是非完全二叉树
    400. 	*/
    401. 	//先创建一个队列类型：
    402. 	Que q;
    403. 	//对队列进行初始化：
    404. 	QueueInit(&q);
    405.  
    406. 	//先将二叉树根节点root放入队列中：
    407. 	if (root != NULL)
    408. 		//二叉树根节点不为空才能放入队列：
    409. 	{
    410. 		//使用队列入队函数QueuePush将根节点（指针）录入：
    411. 		QueuePush(&q, root);
    412. 	}
    413.  
    414. 	//之后再使用while循环，进行层序遍历：
    415. 	while (QueueEmpty(&q) != true)
    416. 		//只要当前队列不为空（队列中还有节点指针）就继续层序遍历：
    417. 	{
    418. 		//使用队列的队头函数QueueFront获取队头的节点指针：
    419. 		BTNode* front = QueueFront(&q);
    420.  
    421. 		//循环遍历过程中如果遇到空节点就终止循环：
    422. 		if (front == NULL)
    423. 			//front为空节点：
    424. 		{
    425. 			break; //终止循环
    426. 		}
    427.  
    428. 		//使用队列入队函数QueuePush将当前左孩子录入队列：
    429. 		QueuePush(&q, front->left);
    430. 		//使用队列入队函数QueuePush将当前右孩子录入队列：
    431. 		QueuePush(&q, front->right);
    432. 		//将当前队头的节点类型出队，判断下个节点：
    433. 		QueuePop(&q);
    434. 	}
    435.  
    436. 	/*
    437. 	执行到这时，队列中队头节点即空节点（NULL）
    438. 	这时再看该空节点 后面的所有节点 还有没有非空节点，
    439. 	后面的所有节点还有 非空节点 的话 -- 说明该二叉树不是连续的，不是完全二叉树
    440. 	后面的所有节点没有 非空节点 的话 -- 说明该树非空节点都是连续的，是完全二叉树
    441. 	*/
    442.  
    443. 	//同样使用while循环进行操作：
    444. 	while (QueueEmpty(&q) != true)
    445. 		//只要当前队列不为空（队列中还有节点指针）就继续循环判断：
    446. 	{
    447. 		//使用队列的队头函数QueueFront获取队头的节点指针：
    448. 		BTNode* front = QueueFront(&q);
    449.  
    450. 		//使用出队函数QueuePop进行出队操作：
    451. 		//（第一次出队时将队头的空节点NULL出队）
    452. 		QueuePop(&q);
    453. 		/*
    454. 		出队后如果当前队头节点为非空节点的话，
    455. 		说明该二叉树不是连续的，不是完全二叉树，
    456. 		则销毁队列并返回false:
    457. 		*/
    458. 		if (front != NULL)
    459. 			//当前队头节点为非空节点：
    460. 		{
    461. 			//销毁队列：
    462. 			QueueDestroy(&q);
    463.  
    464. 			//返回false：
    465. 			return false;
    466. 		}
    467. 	}
    468.  
    469. 	/*
    470. 	执行到这，说明之后已经没有非空节点了
    471. 	说明该树非空节点都是连续的，是完全二叉树，
    472. 	则销毁队列并返回true:
    473. 	*/
    474. 	//销毁队列：
    475. 	QueueDestroy(&q);
    476. 	//返回true：
    477. 	return true;
    478. 	//（ true 以int类型返回 -- 1）
    479. 	//（ false 以int类型返回 -- 0）
    480. }
    481.  
    482.  
    483.  
    484. //计算高度函数 -- 计算当前链式二叉树的高度
    485. //接收二叉树根节点地址（root）
    486. int TreeHeight(BTNode* root)
    487. {
    488. 	//思路：树的高度 = 左右子树中较高树的高度 + 1(根节点)
    489.  
    490. 	//如果该树是空树，返回 0（层）：
    491. 	if (root == NULL)
    492. 		//根节点为空：
    493. 	{
    494. 		//返回 0（层）：
    495. 		return 0;
    496. 	}
    497.  
    498. 	//方法二：使用递归计算左右子树高度并记录，再返回树的高度
    499. 	//递归计算左子树高度：
    500. 	int leftHeight = TreeHeight(root->left);
    501. 	//递归计算右子树高度：
    502. 	int rightHeight = TreeHeight(root->right);
    503.  
    504. 	//再使用三目操作符判断后返回树的高度：
    505. 	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    506. 	//树的高度 = 左右子树中较高树的高度 + 1(根节点)
    507.  
    508.  
    509. 	/*
    510. 	//方法一：使用三目操作符返回树的高度
    511. 	return TreeHeight(root->left) > TreeHeight(root->right)
    512. 		? TreeHeight(root->left) + 1 : TreeHeight(root->right) + 1;
    513. 	//三目操作符选出较高树，再 计算其高度 + 1 = 树的高度
    514. 	*/
    515. 	/*
    516. 	这样可以计算出该树的高度，但是其中含有大量的重复计算，
    517. 	判断较高树时已经递归求了左右子树的高度，
    518. 	在返回树的高度时又重新计算了一遍左右子树的高度，
    519. 	是极其不好的代码
    520. 	*/
    521. }

                

                

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

                

    Queue_BT.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. //包含队列头文件：
    4. #include "Queue_BT.h"
    5.  
    6. //队列初始化函数 -- 将队列进行初始化
    7. //接收队列类型指针(包含链表头尾结点) 
    8. void QueueInit(Que* pq)
    9. {
    10. 	//assert断言队列类型指针不为空：
    11. 	assert(pq != NULL);
    12.  
    13. 	//将队头结点置为空：
    14. 	pq->head = NULL;
    15.  
    16. 	//将队尾结点置为空：
    17. 	pq->tail = NULL;
    18.  
    19. 	//队列结点(元素)个数置为0：
    20. 	pq->size = 0;
    21. }
    22.  
    23.  
    24.  
    25. //队列销毁函数 -- 将队列销毁
    26. //接收队列类型指针(包含链表头尾结点) 
    27. void QueueDestroy(Que* pq)
    28. {
    29. 	//assert断言队列类型指针不为空：
    30. 	assert(pq != NULL);
    31.  
    32. 	//释放队列跟单链表的释放一样
    33. 	//先创建一个在队列进行遍历的指针：
    34. 	QNode* cur = pq->head; //从队头结点开始
    35.  
    36. 	//使用while循环进行遍历释放队列结点：
    37. 	while (cur != NULL)	
    38. 	{
    39. 		//先保存下个结点：
    40. 		QNode* next = cur->next;
    41.  
    42. 		//再释放当前结点：
    43. 		free(cur);
    44.  
    45. 		//再指向下个结点：
    46. 		cur = next;
    47. 	}
    48.  
    49. 	//结点都释放后，把队头队尾指针都置空：
    50. 	pq->head = NULL;
    51. 	pq->tail = NULL;
    52.  
    53. 	//再把队列结点(元素)个数置为0：
    54. 	pq->size = 0;
    55. }
    56.  
    57.  
    58.  
    59. //队列入队函数 -- 用链表的尾插操作实现入队
    60. //接收队列类型指针(包含链表头尾结点) 、尾插值
    61. void QueuePush(Que* pq, QDataType x)
    62. {
    63. 	//assert断言队列类型指针不为空：
    64. 	assert(pq != NULL);
    65.  
    66. 	//入队放入元素需要空间，
    67. 	//所以要先为队列结点开辟动态空间：
    68. 	QNode* newnode = (QNode*)malloc(sizeof(QNode));
    69. 	//检查是否开辟成功：
    70. 	if (newnode == NULL)
    71. 	{
    72. 		//开辟失败则打印错误信息：
    73. 		perror("malloc fail");
    74. 		//终止程序：
    75. 		exit(-1);
    76. 	}
    77.  
    78. 	//队列结点完成后将尾插值(x)
    79. 	//赋给队列结点数据域：
    80. 	newnode->data = x;
    81. 	//指针域指向空：
    82. 	newnode->next = NULL;
    83.  
    84. 	//空间开辟后进行尾插：
    85. 	if (pq->tail == NULL)
    86. 		//如果队列刚初始化，队列为空，
    87. 		//头结点指针和尾结点指针都为空：
    88. 	{
    89. 		//那么将刚开辟的结点newnode地址
    90. 		//赋给头结点指针和尾结点指针
    91. 		pq->head = newnode;
    92. 		pq->tail = newnode;
    93. 	}
    94. 	else
    95. 		//队列不为空，进行尾插：
    96. 	{
    97. 		//将目前队尾结点指针域next指向尾插结点：
    98. 		pq->tail->next = newnode;
    99. 		//然后再指向尾插结点，成为新队尾结点：
    100. 		pq->tail = newnode;
    101. 	}
    102.  
    103. 	//插入数据后队列结点(元素)个数++：
    104. 	pq->size++;
    105. }
    106.  
    107.  
    108.  
    109. //队列出队函数 -- 用链表的头删操作实现出队
    110. //接收队列类型指针(包含链表头尾结点) 
    111. void QueuePop(Que* pq)
    112. {
    113. 	//assert断言队列类型指针不为空：
    114. 	assert(pq != NULL);
    115. 	//assert断言队列不为空，没数据不能删除：  
    116. 	assert(QueueEmpty != true); //不为空就继续程序
    117.  
    118. 	//如果队列中只剩一个结点：
    119. 	if (pq->head->next == NULL)
    120. 		//队头指针指向空，说明只剩一个结点，
    121. 		//只剩一个结点说明队头队尾指针都指向这一个结点，
    122. 		//所以这时头删后头指针移动，尾指针也要移动
    123. 	{
    124. 		//先释放("删除")队列目前头结点：
    125. 		free(pq->head);
    126.  
    127. 		//删除后将队头队尾指针都置为空：
    128. 		pq->head = NULL;
    129. 		pq->tail = NULL;
    130. 	}
    131. 	else
    132. 		//队列不止一个结点，则头删后只需移动队头结点：
    133. 	{
    134. 		//用链表的头删操作实现出队,
    135. 		//先保存第二个结点地址：
    136. 		QNode* next = pq->head->next;
    137.  
    138. 		//释放("删除")队列目前头结点：
    139. 		free(pq->head);
    140.  
    141. 		//再将队头结点指针指向原本第二个结点next，
    142. 		//让其成为新的队头结点：
    143. 		pq->head = next;
    144. 	}
    145.  
    146. 	//“删除”后队列结点(元素)个数--：
    147. 	pq->size--; 
    148. }
    149.  
    150.  
    151.  
    152. //队头函数 -- 返回队头结点的数据域数据
    153. //接收队列类型指针(包含链表头尾结点) 
    154. QDataType QueueFront(Que* pq)
    155. {
    156. 	//assert断言队列类型指针不为空：
    157. 	assert(pq != NULL);
    158. 	//assert断言队列不为空，没数据不能查找：  
    159. 	assert(QueueEmpty != true); //不为空就继续程序
    160.  
    161. 	//队列有数据，则直接返回队头结点数据域数据：
    162. 	return pq->head->data;
    163. }
    164.  
    165.  
    166.  
    167. //队尾函数 -- 返回队尾结点的数据域数据
    168. //接收队列类型指针(包含链表头尾结点) 
    169. QDataType QueueBack(Que* pq)
    170. {
    171. 	//assert断言队列类型指针不为空：
    172. 	assert(pq != NULL);
    173. 	//assert断言队列不为空，没数据不能查找：  
    174. 	assert(QueueEmpty != true); //不为空就继续程序
    175.  
    176. 	//队列有数据，则直接返回队尾结点数据域数据：
    177. 	return pq->tail->data;
    178. }
    179.  
    180.  
    181.  
    182. //判空函数 -- 判断队列是否为空
    183. //接收队列类型指针(包含链表头尾结点) 
    184. bool QueueEmpty(Que* pq)
    185. {
    186. 	//assert断言队列类型指针不为空：
    187. 	assert(pq != NULL);
    188.  
    189. 	//直接判断队头结点指向的下个结点是否为空：
    190. 	return pq->head == NULL; 
    191. 	//是则返回true -- 队列为空
    192. 	//是则返回false -- 队列不为空
    193. }
    194.  
    195.  
    196. //队列大小函数 -- 判断队列结点(元素)个数
    197. //接收队列类型指针(包含链表头尾结点) 
    198. int QueueSize(Que* pq)
    199. {
    200. 	//assert断言队列类型指针不为空：
    201. 	assert(pq != NULL);
    202.  
    203. 	//直接返回size队列结点(元素)个数：
    204. 	return pq->size;
    205. }

                

                

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

                

    Test.c

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. //包含二叉树头文件：
    4. #include "BinaryTree.h"
    5.  
    6.  
    7.  
    8. //测试函数 -- 链式二叉树：
    9. void Test()
    10. {
    11. 	//手动创建多个链式二叉树节点：
    12. 	BTNode* node1 = BuyNode(1);
    13. 	BTNode* node2 = BuyNode(2);
    14. 	BTNode* node3 = BuyNode(3);
    15. 	BTNode* node4 = BuyNode(4);
    16. 	BTNode* node5 = BuyNode(5);
    17. 	BTNode* node6 = BuyNode(6);
    18.  
    19. 	//将多个链式二叉树节点按自己需要连接成链式二叉树：
    20. 	node1->left = node2; //节点1的左指针指向节点2
    21. 	node1->right = node3; //节点1的右指针指向节点3
    22. 	node2->left = node4; //节点2的左指针指向节点4
    23. 	node3->left = node5; //节点3的左指针指向节点5
    24. 	node3->right = node6; //节点3的右指针指向节点6
    25.  
    26. 	//使用PrevOrder函数进行前序（先序）遍历：
    27. 	printf("对当前二叉树进行先序遍历:> ");
    28. 	PrevOrder(node1); //接收根节点
    29. 	printf("\n\n");
    30.  
    31. 	//使用InOrder函数进行中序遍历：
    32. 	printf("对当前二叉树进行中序遍历:> ");
    33. 	InOrder(node1); //接收根节点
    34. 	printf("\n\n");
    35.  
    36. 	//使用PostOrder函数进行后序遍历：
    37. 	printf("对当前二叉树进行后序遍历:> ");
    38. 	PostOrder(node1); //接收根节点
    39. 	printf("\n\n");
    40. 	
    41.  
    42. 	//使用TreeSize计算当前二叉树节点数： 
    43. 	printf("当前二叉树节点个数为:> %d\n", TreeSize(node1));
    44. 	printf("\n");
    45.  
    46. 	//使用TreeLeafSize计算当前二叉树节点数：
    47. 	printf("当前二叉树的叶子节点个数为:> %d\n", TreeLeafSize(node1));
    48. 	printf("\n");
    49.  
    50. 	//使用TreeKLevel计算二叉树中第k层的节点个数：
    51. 	printf("当前二叉树中第3层的节点个数为:> %d\n", TreeKLevel(node1, 3));
    52. 	printf("\n");
    53.  
    54. 	//使用LevelOrder使用队列进行层序遍历：
    55. 	printf("使用层序遍历遍历打印当前二叉树:> ");
    56. 	LevelOrder(node1);
    57. 	printf("\n");
    58.  
    59. 	//使用TreeComplete判断当前链式二叉树是不是完全二叉树：
    60. 	printf("当前二叉树是不是完全二叉树:> %d\n", TreeComplete(node1));
    61. 	printf("\n");
    62.  
    63. 	//使用TreeHeight函数计算当前二叉树的高度：
    64. 	printf("当前二叉树的高度为:> %d\n", TreeHeight(node1));
    65. 	printf("\n");
    66.  
    67. 	//销毁二叉树类型：
    68. 	TreeDestory(node1);
    69. 	//销毁后将其置为空：
    70. 	node1 = NULL;
    71. }
    72.  
    73.  
    74.  
    75. //主函数：
    76. int main()
    77. {
    78. 	Test();
    79.  
    80. 	return 0;
    81. }
  • 相关阅读:
    Google-CTF-2016-Stego.pcap数据包解析
    数据驱动成功：小程序积分商城的数据分析
    C++ Reference: Standard C++ Library reference: C Library: cwchar: wcscspn
    新版本Spring Security 2.7 + 用法，直接旧正版粘贴
    15天深度复习JavaWeb的详细笔记(二)——Maven
    sqli-labs搭建
    PyTorch模型INT8量化基础
    EM算法学习笔记
    Linux环境下使用Docker搭建Jenkins容器
    华为机试 - 滑动窗口最大和
  • 原文地址：https://blog.csdn.net/weixin_63176266/article/details/133616078