目录
一，二叉树需要实现的功能
二，下面是各功能详解
0.思想：
1.创建二叉树结点：
2.通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
3.二叉树销毁：
4.前序遍历：
5.中序遍历：
6.后序遍历：
7.层序遍历：
1.先实现队列的基本功能：
2.基于队列实现层序：
8.计算各类结点数量：
1.计算二叉树结点数量：
2.计算叶子结点数量：
3.计算K层结点数量：
9.二叉树查找值为X的结点：
10.判断二叉树是否为完全二叉树：
一，二叉树需要实现的功能
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);二，下面是各功能详解
0.思想：
下面很多功能都涉及分治的思想（分治法是算法常用的解题方法之一，是将一个大的问题拆分为若干小的问题。）
1.创建二叉树结点：
//重命名存储变量类型，方便更改
typedef char BTDataType;
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;2.通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi) {
if (*pi >= n || a[*pi] == '#') {
(*pi)++;
return NULL;
}
BTNode* Node = (BTNode*)malloc(sizeof(BTNode));
if (Node == NULL) {
perror("BinaryTreeCreate::malloc");
exit(0);
}
Node->_data = a[*pi];
(*pi)++;
Node->_left = BinaryTreeCreate(a, n, pi);
Node->_right = BinaryTreeCreate(a, n, pi);
return Node;
}按照以上所给数组描述，我们创建出的二叉树：
3.二叉树销毁：
二叉树的存储类似链表，可以由前面的结点找到后面的结点，因此二叉树的销毁也是由后向前销毁会方便很多，所以我们采取后序来销毁二叉树
// 二叉树销毁
void BinaryTreeDestory(BTNode** root) {
if (*root == NULL) {
return;
}
BinaryTreeDestory(&(*root)->_left);
BinaryTreeDestory(&(*root)->_right);
free(*root);
*root = NULL;
}4.前序遍历：
i、先访问根结点；
ii、再前序遍历左子树；
iii、最后前序遍历右子树；
算法实现：
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root) {
if (root != NULL) {
printf("%c ", root->_data);
BinaryTreePrevOrder(root->_left);
BinaryTreePrevOrder(root->_right);
}
}
5.中序遍历：
i、中序遍历左子树；
ii、访问根结点；
iii、中序遍历右子树
算法实现：
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root) {
if (root != NULL) {
BinaryTreeInOrder(root->_left);
printf("%c ", root->_data);
BinaryTreeInOrder(root->_right);
}
}
6.后序遍历：
i、后序遍历左子树
ii、后序遍历右子树
iii、访问根结点
算法实现：
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root) {
if (root != NULL) {
BinaryTreePostOrder(root->_left);
BinaryTreePostOrder(root->_right);
printf("%c ", root->_data);
}
}
7.层序遍历：
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
思路：层序遍历需要用到队列的知识，就是先将根结点入队，判断队列是否为空，循环将队首元素出队的同时队首元素子节结点入队
算法实现：
1.先实现队列的基本功能：
typedef BTNode QDataType;
// 链式结构：表示队列
typedef struct QListNode
{
struct QListNode* _next;
QDataType* _data;
}QNode;
// 队列的结构
typedef struct Queue
{
QNode* _front;
QNode* _rear;
}Queue;
// 初始化队列
void QueueInit(Queue* q) {
assert(q);
q->_front = NULL;
q->_rear = NULL;
}
int QueueEmpty(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType* data) {
assert(q);
QNode* tmp = (QNode*)malloc(sizeof(QNode));
if (tmp == NULL) {
perror("QueuePush:malloc");
return;
}
tmp->_data = data;
tmp->_next = NULL;
if (QueueEmpty(q)) {
q->_front = tmp;
q->_rear = tmp;
}
q->_rear->_next = tmp;
q->_rear = tmp;
}
// 队头出队列
void QueuePop(Queue* q) {
if (QueueEmpty(q)) {
printf("Pop: Queue is empty\n"); // 更清晰的错误信息
exit(0);
}
q->_front = q->_front->_next;
//free(tmp);
}
// 获取队列头部元素
QDataType* QueueFront(Queue* q) {
return q->_front->_data;
}
// 获取队列队尾元素
QDataType* QueueBack(Queue* q) {
return q->_rear->_data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q) {
QNode* cur = q->_front;
int size = 0;
while (cur) {
size++;
cur = cur->_next;
}
return size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q) {
assert(q);
if (q->_front == NULL) {
return 1;
}
return 0;
}
// 销毁队列
void QueueDestroy(Queue* q) {
assert(q);
while (!QueueEmpty(q)) {
QueuePop(q);
}
}2.基于队列实现层序：
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root) {
Queue* queue = (Queue*)malloc(sizeof(Queue));
BTNode* front;
QueueInit(queue);
if (root) {
QueuePush(queue, root);
}
while (!QueueEmpty(queue)) {
front = QueueFront(queue);
if (front->_left)
{
QueuePush(queue, front->_left);
}
if (front->_right)
{
QueuePush(queue, front->_right);
}
printf("%c ",front->_data);
QueuePop(queue);
}
printf("\n");
QueueDestroy(queue);
}8.计算各类结点数量：
1.计算二叉树结点数量：
// 二叉树节点个数
int BinaryTreeSize(BTNode* root) {
if (root == NULL) {
return 0;
}
else {
return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}
}2.计算叶子结点数量：
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root) {
if (root == NULL) {
return 0;
}
if (root->_left == NULL && root->_right == NULL) {
return 1;
}
else {
return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}
}3.计算K层结点数量：
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k) {
if (root == NULL) {
return 0;
}
if (k == 1) {
return 1;
}
return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}9.二叉树查找值为X的结点：
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x) {
if (root==NULL) {
return NULL;
}
if (root->_data == x) {
return root;
}
BTNode* r1 = BinaryTreeFind(root->_left, x);
if (r1 != NULL) {
return r1;
}
return BinaryTreeFind(root->_right, x);
}10.判断二叉树是否为完全二叉树：
根据完全二叉树的定义，具有n个结点的完全二叉树与满二叉树中编号从1~n的结点一一对应。
算法思想：采用层次遍历算法，将所有结点加入队列（包括空结点）。遇到空结点时，查看其后是否有非空结点。若有，则二叉树不是完全二叉树。
判断二叉树是否为完全二叉树是二叉树层序遍历的基本用途之一，也要借助队列来实现；
算法实现：
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root) {
Queue queue;
QueueInit(&queue);
if (root) {
QueuePush(&queue, root);
}
while (!QueueEmpty(&queue)) {
BTNode* front = QueueFront(&queue);
QueuePop(&queue);
if (front == NULL) {
break;
}
QueuePush(&queue, front->_left);
QueuePush(&queue, front->_right);
}
while (!QueueEmpty(&queue)) {
BTNode* front = QueueFront(&queue);
QueuePop(&queue);
if (front) {
QueueDestroy(&queue);
return 0;
}
}
QueueDestroy(&queue);
return 1;
}
