目录
树
树的概念
树是一种非线性的数据结构,它是由n个有限节点组成的具有层次关系的集合。每一个节点代表一个元素,由父节点和子节点的层次关系连接。它被叫做树的原因是因为看起来像一颗倒挂的树(根朝上,叶子朝下)。
- 树的顶部节点就是根节点,他没有父节点。
- 除根节点外,其余结点被分为M(M>0)个不相关的集合T1,T2,T3…Tm,其中每一个集合Ti(1<=i<=m)又是一个与树类似的子树,每棵子树的根节点有且只有一个父节点,可以有0个或多个子节点。
所以树都是递归定义的。
在树形结构中,子树之间不能有交集,否则就不是树形结构。
有关树的基本概念
- 节点(Node):树中的每个元素都被视为一个节点。
- 根节点(Root):树的顶部节点,没有父节点。
- 子节点(Child):与另一节点通过有向边相连的节点,称为子节点。
- 父节点(Parent):如果一个节点指向另一个节点,那么这个节点是子节点的父节点。
- 叶节点(Leaf):没有子节点的节点。
- 边(Edge):连接两个节点的有向连接,一棵树有N个节点,就有N-1条边
- 路径(Path):从树中一个节点到另一个节点的一系列边。
- 深度(Depth):从根节点到特定节点的路径长度。
- 高度(Height):从特定节点到最远叶节点的路径长度。
- 节点的度:一个节点含有的子树或者节点的个数,如上图:A的度为6。
- 兄弟节点:具有相同的父节点的节点,如上图:B、D是兄弟节点。
- 树的度:一棵树中,具有最多子节点的节点的度,如上图:树的度为6。
- 节点的层次:从根节点开始,根为第一层,根的子节点为第二层,以此类推。
- 树的高度:树中节点的最大层次,如上图:树的高度为4.
- 森林:由m个互不相交的树的集合。
树的表示
树结构的表示相较于线性表就比较麻烦,因为既要保存值域,也要保存节点和节点的关系。
树常用的表示方法有:
-
节点链接表示
-
数组表示
-
双亲表示
-
孩子-兄弟表示
我们了解下最常用的孩子兄弟表示法。
typedef int DataType;
struct Node
{
struct Node* firstChild1;
struct Node* pNextBrother;
DataType data;
};
这种表示法的优势在于便于插入删除节点(修改指针即可)、方便遍历所有节点、适用于表示有多个孩子或需要频繁变更结构的树
树的实际应用
- Linux树状目录结构
除此之外,树还可以用于文件系统、组织结构图、数据库索引和优先队列和堆等等。
二叉树
概念
在一棵树中,每个节点最多只有两个子节点(通常称为左节点和右节点),就是叫做二叉树。
- 二叉树没有度为2的节点。
- 二叉树的子树有左右之分,次序不能颠倒。
任意二叉树都是有以下几种情况复合而成的。
常见类型
-
满二叉树:所有层都是满的,即除了叶节点外,每个节点都有两个子节点。
-
完全二叉树:除去最后一层外,其他层的节点都是满的。(叶子节点那层可满可不满)满二叉树是一种特殊的完全二叉树。在最后一层,所有的节点都尽可能地集中在左侧连续排列。也就是说,如果最后一层不是满的,那么这些未填充的空位(如果存在)只能出现在右侧。
二叉树的性质
1.规定根节点的层数为1,一棵非空二叉树的第i层最多有2 ^ (i - 1)个节点。
最多是因为该层可能是最最后一层,不是满节点。
2.深度为h的二叉树的最大节点个数是2 ^ h - 1。
3.一棵二叉树,度为0的节点个数为n0,度为2的节点个数为n2,则n0 = n2 + 1。(度为0的节点比度为2节点多一个)
4.n个节点的满二叉树的深度h = log(n + 1)(以2为底)
二叉树的存储结构
1.顺序存储
顺序存储就是使用数组来存储,一般适合完全二叉树,如果不是的话会浪费空间,真正用数组存储的是堆(一种特殊的完全二叉树)。
二叉树顺序存储在物理上是一个数组,在逻辑上是一颗二叉树。
- 若父节点的索引为i,则左孩子为2 * i + 1,右孩子为2 * i + 2。
- 若孩子的索引为i,则父亲为 (i - 1) / 2。(因为除法是整除的,即使是右孩子 2 * i + 2,在减一除2后得到的也是i)
2.链式存储
链式存储就是用链表来表示一棵二叉树,每个节点由数据和左右指针构成。
typedef int BTDataType;
typedef struct BinarytreeNode
{
BTDataType data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
链式结构又分为二叉链和三叉链,我们先来学习用二叉链实现的树。
二叉树链式结构的实现
前置
我们先要创建一棵二叉树,这样是为了便于后后序操作的进行。
注意:这不是真正的创建操作,这只是暴力创建一棵二叉树,是为了方便后续的学习与操作。
typedef int BTDataType;
typedef struct BinarytreeNode
{
BTDataType data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
BTNode* BuyBTNode(BTDataType x)
{
BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
if (newnode == NULL)
{
perror("malloc fail");
return;
}
newnode->data = x;
newnode->left = NULL;
newnode->right = NULL;
}
BTNode* CreatBTNode()
{
BTNode* node1 = BuyBTNode(1);
BTNode* node2 = BuyBTNode(2);
BTNode* node3 = BuyBTNode(3);
BTNode* node4 = BuyBTNode(4);
BTNode* node5 = BuyBTNode(5);
BTNode* node6 = BuyBTNode(6);
node1->left = node2;
node1->right = node4;
node2->left = node3;
node4->left = node5;
node4->right = node6;
return node1;
}
二叉树的遍历
二叉树的遍历是按照某种顺序访问树中的所有节点,而不需要改变树的结构。
二叉树的遍历方法有
- 前序遍历(Preorder Traversal)
- 中序遍历(Inorder Traversal)
- 后序遍历(Postorder Traversal)
- 层序遍历(Levelorder Traversal)
前序遍历
访问顺序:根节点 -> 左子树 -> 右子树
首先访问根节点,然后递归前序遍历左子树,接着是右子树。
递归实现
// 二叉树前序遍历
void PrevOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
printf("%d ", root->data);
PrevOrder(root->left);
PrevOrder(root->right);
}
中序遍历
访问顺序:左子树 -> 右子树 -> 根节点。
首先递归进行中序遍历左子树,然后访问根节点,最后递归地进行中序遍历右子树。
递归实现
// 二叉树中序遍历
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
后序遍历
访问顺序:左子树 -> 右子树 -> 根节点。
递归地进行后序遍历左子树,接着右子树,最后访问根节点。
递归实现
//二叉树后序遍历
void PostOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}
层序遍历
二叉树的层序遍历,也称为广度优先遍历,按照从上到下、从左往右地顺序访问二叉树的节点。
这种遍历通常使用队列实现。
基本步骤:
- 初始化:创建一个队列,将根节点(如果存在)入队列。
- 遍历循环:队列非空时,弹出队列前端节点,访问该节点(如:打印节点的值),将该节点的左子节点和右子节点入队列。
- 继续:重复步骤2,直到队列为空。
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
printf("%d ", front->data);
if (front->left)
QueuePush(&q, front->left);
if (front->right)
QueuePush(&q, front->right);
}
QueueDestroy(&q);
}
二叉树的相关接口
节点的个数
终止情况 节点为空则返回0。
单层递归处理逻辑 返回1 + 左子树节点的个数 + 右子树节点的个数
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
return root == NULL ? 0 :
1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
这里把终止情况和在一起了。
叶子节点的个数
终止情况 节点为空返回0;节点的左右子树为空返回1。
单层递归处理逻辑 返回左子树的叶子节点个数和右子树节点个数。
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL) return 0;
if (root && root->left == NULL && root->right == NULL) return 1;
return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}
二叉树高度
终止情况 节点为空返回0;节点的左右子树为空返回1。
单层递归处理逻辑 求出左子树和右子树的高度,比较一下,返回较大高度 + 1(加1是为了算上根节点)
//二叉树高度
int BinaryTreeHight(BTNode* root)
{
if (root == NULL) return 0;
if (root && root->left == NULL && root->right == NULL) return 1;
int lefthight = BinaryTreeHight(root->left);
int righthight = BinaryTreeHight(root->right);
return (lefthight > righthight ? lefthight : righthight) + 1;
}
注意:这里左子树高度和右子树高度一定要存起来,不能直接放在return里,不然的话递归次数会指数级增加的
(BinaryTreeHight(root->left) > BinaryTreeHight(root->right) ?
BinaryTreeHight(root->left) : BinaryTreeHight(root->right)) + 1
上面这种写法是完全错误的写法,一定要避免。
第k层节点个数
终止情况 节点为空返回0;k == 1返回1。
单层递归处理逻辑 返回左子树k-1层节点的个数和右子树k-1层节点的个数。
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k) //左子树的k-1层,右子树的k-1层
{
if (root == NULL) return 0;
if (k == 1) return 1;
return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}
查找值为x的节点
终止情况 节点为空返回空指针;找到值相等的节点,返回该节点。
单层递归处理逻辑 递归地去左子树找,找到了返回,找不到就去右子树找,找到了返回,两棵子树都没找到返回空指针。
// 二叉树查找值为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;
}
销毁二叉树
后序遍历的一个应用,递归访问左子树,然后右子树,销毁根节点。
//二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
if (root == NULL)
return;
BinaryTreeDestory(root->left);
BinaryTreeDestory(root->right);
free(root);
}
判断二叉树是否为完全二叉树
基本思想
将这棵树当成完全二叉树,将其节点(包括空节点)入队列,出队列时带入左右节点,当出队列访问到的节点为空时,不再入队列,然后遍历队列,发现有非空节点,说明不是完全二叉树,返回false,遍历完就返回true。
bool BinaryTreeComplete(BTNode* root)
{
Queue q;
QueueInit(&q);
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
if (front == NULL)
break;
QueuePop(&q);
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
if (front)
return false;
QueuePop(&q);
}
return true;
}
通过前序遍历创建二叉树
给定一个前序遍历的数组,创建二叉树。
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
if (a[*pi] == '#')
{
(*pi)++;
return NULL;
}
BTNode* root = (BTNode*)malloc(sizeof(BTNode));
if (root == NULL)
{
perror("malloc fail!");
return NULL;
}
root->data = a[(*pi)++];
root->left = BinaryTreeCreate(a, n, pi);
root->right = BinaryTreeCreate(a, n, pi);
return root;
}
拜拜,下期再见😏
摸鱼ing😴✨🎞