二叉树是一种常见的数据结构,每个节点最多有两个子节点,通常称为左子节点和右子节点。实现二叉树通常涉及定义节点类(包含数据和指向子节点的指针)以及相应的插入、删除和查找操作。遍历二叉树则是访问其所有节点的过程,常见的遍历方式有前序遍历(根-左-右)、中序遍历(左-根-右)和后序遍历(左-右-根)。这些遍历方法可以递归或迭代实现,对于理解二叉树结构和操作非常重要。
在学习二叉树的基本操作前,需先要创建一棵二叉树,然后才能学习其相关的基本操作。由于现在各位读者对二叉树结构掌握还不够深入,为了降低大家学习成本,此处手动快速创建一棵简单的二叉树,快速进入二叉树操作学习,等二叉树结构了解的差不多时,我们反过头再来研究二叉树真正的创建方式。
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;
BTNode* CreatBinaryTree()
{
BTNode* node1 = BuyNode(1);
BTNode* node2 = BuyNode(2);
BTNode* node3 = BuyNode(3);
BTNode* node4 = BuyNode(4);
BTNode* node5 = BuyNode(5);
BTNode* node6 = BuyNode(6);
node1->_left = node2;
node1->_right = node4;
node2->_left = node3;
node4->_left = node5;
node4->_right = node6;
return node1;
}
注意:上述代码并不是创建二叉树的方式,真正创建二叉树方式见下文
再看二叉树基本操作前,再回顾下二叉树的概念,二叉树是:
从概念中可以看出,二叉树定义是递归式的,因此后序基本操作中基本都是按照该概念实现的。
学习二叉树结构,最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则,依次对二叉树中的节点进行相应的操作,并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一,也是二叉树上进行其它运算的基础。
按照规则,二叉树的遍历有:前序/中序/后序的递归结构遍历:
由于被访问的结点必是某子树的根,所以N(Node)
、L(Left subtree)
和R(Right subtree)
又可解释为根、根的左子树和根的右子树。NLR
、LNR
和LRN
分别又称为先根遍历、中根遍历和后根遍历。
// 二叉树前序遍历
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);
// 二叉树前序遍历
void PreOrder(BTNode* root);
void PreOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL->");
return;
}
printf("%d->", root->val);
PreOrder(root->left);
PreOrder(root->right);
}
// 二叉树中序遍历
void InOrder(BTNode* root);
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL->");
return;
}
InOrder(root->left);
printf("%d->", root->val);
InOrder(root->right);
}
// 二叉树后序遍历
void PostOrder(BTNode* root);
void PostOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL->");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d->", root->val);
}
下面主要分析前序递归遍历,中序与后序图解类似。
前序遍历递归图解:
前序遍历结果:1 2 3 4 5 6
中序遍历结果:3 2 1 5 4 6
后序遍历结果:3 2 5 6 4 1
层序遍历:除了先序遍历、中序遍历、后序遍历外,还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1,层序遍历就是从所在二叉树的根节点出发,首先访问第一层的树根节点,然后从左到右访问第2层上的节点,接着是第三层的节点,以此类推,自上而下,自左至右逐层访问树的结点的过程就是层序遍历。
// 层序遍历
void LevelOrder(BTNode* root);
使用队列的形式来实现层序遍历——队列
void BinaryTreeLevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if(root)QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front)
{
printf("%c ", front->val);
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
else
{
printf(" N ");
}
}
printf("\n");
QueueDestroy(&q);
}
层序遍历(也称为广度优先遍历)是一种树的遍历方法,它按照树的层次顺序访问节点。具体来说,从根节点开始,先访问所有相邻的子节点,然后逐层向下遍历,每访问一层的节点,就转向下一层,直到遍历完所有节点。这种遍历方法常用于二叉树、多叉树和图等数据结构。在二叉树中,通常使用队列来实现层序遍历,首先将根节点入队,然后不断从队列中出队节点并访问,同时将该节点的子节点入队,直到队列为空。层序遍历的时间复杂度通常为O(n),其中n为节点数,空间复杂度取决于队列的大小,最坏情况下为O(n)。
请写出下面的前序/中序/后序/层序遍历
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)return 0;
return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}
该段代码定义了一个名为BinaryTreeSize
的函数,用于计算二叉树中节点的总数。函数接受一个指向二叉树根节点的指针root
作为参数。如果root
为空,则返回0;否则,递归计算左子树和右子树的节点数,并将它们相加,再加上根节点本身,最终返回整个二叉树的节点总数。
二叉树是每个节点最多有两个子节点的树结构,通常子节点被称为“左子节点”和“右子节点”。二叉树的节点个数是指树中所有节点的总数,包括根节点、内部节点(非叶子节点)和叶子节点。计算二叉树的节点个数可以通过遍历树的所有节点来实现,例如使用前序遍历、中序遍历或后序遍历等方法。在遍历过程中,每访问一个节点,就将计数器加1,最终计数器的值就是二叉树的节点个数。此外,对于完全二叉树和满二叉树等特殊类型的二叉树,其节点个数可以通过特定的公式直接计算得出。
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
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);
}
该函数BinaryTreeLeafSize
计算二叉树的叶子节点数量。如果根节点为空,返回0;如果根节点是叶子节点(即没有左右子节点),返回1;否则,递归计算左子树和右子树的叶子节点数量并返回它们的和。
二叉树的叶子节点是指没有子节点的节点。要计算二叉树的叶子节点个数,可以采用递归或迭代的方法。递归方法的基本思路是,对于每个节点,如果它是叶子节点,则计数加1;否则,递归计算其左右子树的叶子节点个数并相加。迭代方法则可以利用队列或栈等数据结构,层次遍历或深度优先遍历二叉树,统计叶子节点的个数。无论采用哪种方法,最终得到的叶子节点个数即为二叉树的叶子节点总数。
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
int BinaryTreeLevelKSize(BTNode* root, int k)
{
assert(k > 0);
if (root == NULL)return 0;
if (k == 1)return 1;
return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
该函数BinaryTreeLevelKSize
计算了二叉树中第k层的节点数量。首先,它检查k是否大于0并确认根节点root
是否存在。如果root
为空,则返回0。如果k等于1,表示要求的是第一层的节点数,直接返回1。否则,它递归地对左子树和右子树调用自身,计算第k-1层的节点数,然后将这两个结果相加得到第k层的节点数。
二叉树第k层的节点个数可以通过递归或迭代方法计算。在递归方法中,对于给定的二叉树,我们首先检查根节点是否为空。如果为空,则树为空,返回0。否则,我们递归地计算左子树和右子树的第k-1层节点数,并将它们相加得到第k层的节点数。在迭代方法中,我们使用队列进行层序遍历,记录每一层的节点数,直到找到第k层或遍历完整个树。最终,返回第k层的节点数。这两种方法的时间复杂度均为O(n),其中n为二叉树中节点的总数。
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)return NULL;
if (root->val == x)return root;
BTNode* left = BinaryTreeFind(root->left, x);
if (left)
return left;
BTNode* right = BinaryTreeFind(root->right, x);
if (right)
return right;
return NULL;
}
该函数是一个在二叉树中查找指定值的函数。它接受一个二叉树的根节点和一个要查找的值x
作为参数。如果根节点为空,则返回NULL
。如果根节点的值与x
相等,则返回根节点。否则,它递归地在左子树和右子树中查找x
。如果在左子树或右子树中找到x
,则返回对应的节点。如果在整棵树中都没有找到x
,则返回NULL
。
//二叉树销毁
void Binary Tree Destory (BTNode** root) ;
void BinaryTreeDestroy(BTNode** root)
{
if ((*root) == NULL)return;
BinaryTreeDestroy(&(*root)->left);
BinaryTreeDestroy(&(*root)->right);
free(*root);
*root = NULL;
}
该函数BinaryTreeDestroy
是一个用于销毁二叉树的递归函数。它接受一个指向二叉树根节点指针的指针root
。首先,它检查根节点是否为空,如果为空则直接返回。否则,它递归地销毁左子树和右子树,然后释放根节点的内存,并将根节点指针设置为NULL
,从而完成整个二叉树的销毁。
// 通过前序遍历的数组" A B D # # E # H # # C F # # G # # " 构建二叉树
BTNode* Binary TreeCreate(BTDataType* a,int n,int* pi) ;
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
if (a == NULL || n <= 0)return NULL;
if (a[*pi] == ' ')
{
(*pi)++;
return NULL;
}
BTNode* root = (BTNode*)malloc(sizeof(BTNode));
root->val = a[(*pi)++];
root->left = BinaryTreeCreate(a, n, pi);
root->right = BinaryTreeCreate(a, n, pi);
return root;
}
该段代码实现了一个二叉树的创建函数。它接收三个参数:一个数据类型数组a
,一个整数n
表示数组长度,以及一个整数指针pi
指向数组中当前要处理的元素索引。函数首先检查输入是否有效,若数组为空或n
小于等于0,则返回NULL
。若当前元素为空格,则递增索引并返回NULL
。否则,创建一个新的二叉树节点,将当前元素赋值给节点的值,并递归地创建左右子树。最后返回新创建的根节点。
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);
bool BinaryTreeComplete(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front)
{
printf("%c ", front->val);
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
if (front)
{
QueueDestroy(&q);
return false;
}
}
}
QueueDestroy(&q);
return true;
}
此函数BinaryTreeComplete
检查给定的二叉树root
是否是完全二叉树。它使用一个队列q
进行层序遍历。首先,如果根节点存在,则将其入队。然后在队列不为空的情况下,反复取出队首节点并打印其值,然后将它的左右子节点入队。如果在遍历过程中发现队列中出现了空节点,则立即销毁队列并返回false
,因为完全二叉树在层序遍历中不应出现空节点。如果遍历结束,即队列为空,且没有发现空节点,则销毁队列并返回true
,说明是完全二叉树。
1.A 2.A 3.D 4.A
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
typedef char BTDataType;
typedef struct BinaryTreeNode
{
BTDataType val;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
typedef BTNode* QDatatype;
typedef struct QueueNode
{
QDatatype val;
struct QueueNode* next;
}QNode;
typedef struct Queue
{
QNode* phead;
QNode* 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);
//创建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
//二叉树的销毁
void BinaryTreeDestroy(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);
// 判断二叉树是否是完全二叉树
bool BinaryTreeComplete(BTNode* root);
#include "Tree.h"
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = NULL;
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 = NULL;
pq->ptail = NULL;
pq->size = 0;
}
void QueuePush(Queue* pq, QDatatype x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("newnode malloc :");
return;
}
newnode->val = x;
newnode->next = NULL;
if (pq->ptail)
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
else
{
pq->phead = pq->ptail = newnode;
}
pq->size++;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->size == 0;
}
void QueuePop(Queue* pq)
{
assert(pq);
//assert(!QueueEmpty(pq));
assert(pq->phead != NULL);
if (pq->phead->next == NULL)
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
else
{
QNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
}
pq->size--;
}
QDatatype QueueFront(Queue* pq)
{
assert(pq);
assert(pq->phead != NULL);
return pq->phead->val;
}
QDatatype QueueBack(Queue* pq)
{
assert(pq);
assert(pq->ptail != NULL);
return pq->ptail->val;
}
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
if (a == NULL || n <= 0)return NULL;
if (a[*pi] == ' ')
{
(*pi)++;
return NULL;
}
BTNode* root = (BTNode*)malloc(sizeof(BTNode));
root->val = a[(*pi)++];
root->left = BinaryTreeCreate(a, n, pi);
root->right = BinaryTreeCreate(a, n, pi);
return root;
}
void BinaryTreeDestroy(BTNode** root)
{
if ((*root) == NULL)return;
BinaryTreeDestroy(&(*root)->left);
BinaryTreeDestroy(&(*root)->right);
free(*root);
*root = NULL;
}
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)return 0;
return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}
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);
}
int BinaryTreeLevelKSize(BTNode* root, int k)
{
assert(k > 0);
if (root == NULL)return 0;
if (k == 1)return 1;
return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)return NULL;
if (root->val == x)return root;
BTNode* left = BinaryTreeFind(root->left, x);
if (left)
return left;
BTNode* right = BinaryTreeFind(root->right, x);
if (right)
return right;
return NULL;
}
void BinaryTreePrevOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
printf("%c ", root->val);
BinaryTreePrevOrder(root->left);
BinaryTreePrevOrder(root->right);
}
void BinaryTreeInOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreeInOrder(root->left);
printf("%c ", root->val);
BinaryTreeInOrder(root->right);
}
void BinaryTreePostOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreePostOrder(root->left);
BinaryTreePostOrder(root->right);
printf("%c ", root->val);
}
bool BinaryTreeComplete(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front)
{
printf("%c ", front->val);
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
if (front)
{
QueueDestroy(&q);
return false;
}
}
}
QueueDestroy(&q);
return true;
}
#include "Tree.h"
int main()
{
char a[] = { 'a','b','c',' ',' ','d','e',' ','g',' ',' ','f',' ',' ',' ' };
int pi = 0;
BTNode* root = BinaryTreeCreate(a, sizeof(a) / sizeof(a[0]), &pi);
BinaryTreePrevOrder(root);
printf("\n");
BinaryTreeInOrder(root);
printf("\n");
BinaryTreePostOrder(root);
printf("\n");
printf("TreeSize : %d\n", BinaryTreeSize(root));
printf("TreeKLevel : %d\n", BinaryTreeLevelKSize(root, 3));
BTNode* ret = BinaryTreeFind(root, 3);
printf("TreeFind : %p\n", ret);
BinaryTreeLevelOrder(root);
printf("\n");
printf("BinaryTreeComplete %d\n ", BinaryTreeComplete(root));
BinaryTreeDestroy(&root);
root = NULL;
return 0;
}