文章目录

写在前面
二叉树的创建
二叉树的遍历
- 前序遍历
- 中序遍历
- 后序遍历
- 层序遍历
二叉树的销毁
二叉树节点个数
二叉树叶子节点的个数
二叉树查找值为x的节点
二叉树是否为完全二叉树

写在前面

二叉树的几乎所有实现都是依靠递归实现，递归的核心思路是把任何一个二叉树看成根和左右子树，而二叉树递归的核心玩法就是把二叉树的左右子树再看成根，再找左右子树，再看成根…

因此，解决二叉树问题实际上要把二叉树转换成一个一个子树的过程，找到一个一个的子树再组装起来就形成了二叉树

二叉树的创建

二叉树建立的正统方法是利用递归，这里展示递归的一种写法

BTNode* BuyNode(BTDataType a)
{BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));newnode->data = a;newnode->left = NULL;newnode->left = NULL;return newnode;
}BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{if (a[*pi] == '#'){(*pi)++;return NULL;}BTNode* root = BuyNode(a[*pi]);(*pi)++;root->left = BinaryTreeCreate(a, pi);root->right = BinaryTreeCreate(a, pi);return root;
}

如果你对递归的认识并不熟悉，下面我画了一幅递归展开图，更好解释这其中的原理

在这里插入图片描述
(右子树的部分过程由于空间原因不够完全展开，但如果看懂左子树的构建过程，右子树不难自己画出)

这里注意的是，函数栈帧的创建并不是每一个都不一样的位置，当一个栈帧被销毁后，另外一个栈帧创建就会在原来的位置，因此在计算空间复杂度的时候需要考虑这个问题：
空间是可以重复利用的，时间是一去不复返的

从这幅图中，相信可以理解这段代码的含义了

首先创建一个根节点，根节点去寻找左子树进入递归，而进入递归后继续寻找左子树…直到遇到NULL截止，而遇到空后就寻找右子树，右子树也找到空后返回，这样就构建出了二叉树中最小的一棵树，而这棵树会返回，作为根的左子树，然后继续进入递归寻找根的右子树…

由于是借助链表进行实现的，因此我们可以理解为首先创建好根，而根的左右子树用函数创建好后再连接起来…当遇到#就返回，形成了一个一个的小树，小树最后组成大树，就形成了二叉树

二叉树的遍历

二叉树的遍历主要有前序遍历，中序遍历，后序遍历，层序遍历

前序遍历

前序遍历是指遍历时先访问根，再访问左子树，再访问右子树

代码实现如下

void BinaryTreePrevOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}printf("%c ", root->data);BinaryTreePrevOrder(root->left);BinaryTreePrevOrder(root->right);
}

下面依旧画出它的递归展开图

在这里插入图片描述

中序遍历

中序遍历是先访问左子树，再访问根，最后访问右子树

void BinaryTreeInOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}BinaryTreeInOrder(root->left);printf("%c ", root->data);BinaryTreeInOrder(root->right);
}

递归图和上面基本类似，就不做画出了

后序遍历

后序遍历是先访问左子树，再访问右子树，最后访问根

void BinaryTreePostOrder(BTNode* root)
{if (root == NULL){printf("N ");return;}BinaryTreePostOrder(root->left);BinaryTreePostOrder(root->right);printf("%c ", root->data);
}

递归图和上面基本类似，就不做画出了

层序遍历

层序遍历指的是对二叉树进行一层一层的遍历，每一层分别遍历，这里借助队列进行遍历，基本思路把根放到队列中，当某一个根要出队列时，就令该根的左子树和右子树进队列，这样就能实现一层一层遍历，画法如下：

在这里插入图片描述
代码实现相较于前面来说简单一些，但需要引入队列的，关于队列的介绍：

数据结构—手撕队列栈并相互实现

下面展示要使用的队列的相关函数实现

// queue.h
typedef struct BinaryTreeNode* QDataType;typedef struct QNode
{QDataType data;struct QNode* next;
}QNode;typedef struct Queue
{QNode* phead;QNode* ptail;int size;
}Queue;// queue.c
void QueueInit(Queue* pq)
{assert(pq);pq->phead = pq->ptail = NULL;pq->size = 0;
}void QueueDestroy(Queue* pq)
{assert(pq);QNode* cur = pq->phead;while (cur){QNode* next = cur->next;free(cur);cur = next;}pq->phead = pq->ptail = NULL;pq->size = 0;
}QNode* BuyQnode(QDataType x)
{QNode* newnode = (QNode*)malloc(sizeof(QNode));if (newnode == NULL){perror("malloc fail");return NULL;}newnode->data = x;newnode->next = NULL;return newnode;
}void QueuePush(Queue* pq, QDataType x)
{assert(pq);QNode* newnode = BuyQnode(x);if (pq->ptail == NULL){assert(pq->phead == NULL);pq->phead = pq->ptail = newnode;}else{pq->ptail->next = newnode;pq->ptail = newnode;}pq->size++;
}bool QueueEmpty(Queue* pq)
{if (pq->size == 0){return true;}return false;
}void QueuePop(Queue* pq)
{assert(pq);assert(!QueueEmpty(pq));if (pq->phead->next == NULL){free(pq->phead);pq->phead = pq->ptail = NULL;}else{QNode* newhead = pq->phead->next;free(pq->phead);pq->phead = newhead;}pq->size--;
}QDataType QueueFront(Queue* pq)
{assert(pq);assert(!QueueEmpty(pq));return pq->phead->data;
}QDataType QueueBack(Queue* pq)
{assert(pq);return pq->ptail->data;
}int QueueSize(Queue* pq)
{assert(pq);return pq->size;
}

那么借助队列我们来实现刚才的层序遍历

void BinaryTreeLevelOrder(BTNode* root)
{Queue q;QueueInit(&q);if (root){QueuePush(&q, root);}while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);printf("%c ", front->data);QueuePop(&q);if (front->left)QueuePush(&q, front->left);if(front->right)QueuePush(&q, front->right);}printf("\n");//BinaryTreeDestory(&q);
}

二叉树的销毁

在知道了遍历的多种途径后，二叉树的销毁就很简单了，在确定代码如何实现前，先思考问题：应该选用哪种遍历来进行二叉树的销毁？

结果是很明显的，选用后序遍历是最方便的，原因在于销毁是需要进行节点的释放的，如果使用前序或者中序遍历，那么在遍历的过程中根节点会被先销毁，那么找左子树或者右子树就带来了不便(可以定义一个变量保存位置)，因此最好用后序遍历，把子树都销毁了最后销毁根

void BinaryTreeDestory(BTNode* root)
{if (root == NULL){return;}BinaryTreeDestory(root->left);BinaryTreeDestory(root->right);free(root);
}

二叉树节点个数

二叉树节点个数也是转换成子树来解决，如果为NULL就返回0，其他情况返回左右相加再加上节点本身

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;}int leftleave = BinaryTreeSize(root->left);int rightleave = BinaryTreeSize(root->right);return leftleave + rightleave;
}

二叉树查找值为x的节点

这个相对较麻烦一点，先上展开图和代码

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{if (root == NULL){return NULL;}if (root->data == x){return root;}BTNode* ret1 = BinaryTreeFind(root->left, x);if (ret1)return ret1;BTNode* ret2 = BinaryTreeFind(root->right, x);if (ret2)return ret2;return NULL;
}

在这里插入图片描述
这里的关键动作就是判断ret1和ret2是否为空，如果是，则说明找到正确的值，那么就会一路被送出函数，相反会一直返回NULL，因此就不必担心送出其他元素的情况

二叉树是否为完全二叉树

这个思路也较为复杂，首先，需要解决的问题是用什么思路，基本思路是一个一个看，如果在某一个节点已经为空的前提下，它后面的节点还不为空，那么就说明这个不是完全二叉树

因此这个思路是不是和层序遍历很像呢？我们借助这样的思路继续写下去

当队列不为空就继续入队列出队列进行层序遍历，当遇到空就跳出，跳出循环后此时队列并不为空，继续出队列，如果发现某个元素不为空，那么就证明这并不是完全二叉树

代码实现如下：

int BinaryTreeComplete(BTNode* root)
{assert(root);Queue q;QueueInit(&q);while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);if (front == NULL){break;}QueuePush(&q,front->left);QueuePush(&q,front->right);}while (!QueueEmpty(&q)){BTNode* front = QueueFront(&q);QueuePop(&q);if (front){BinaryTreeDestory(&q);return 0;}}BinaryTreeDestory(&q);return 1;
}