本文详细介绍了树和二叉树的概念、基本术语、性质，包括树的表示方法（如孩子兄弟表示法），以及二叉树的特殊类型如完全二叉树、满二叉树和斜树。还重点讨论了堆数据结构，包括堆排序和小堆/大堆的实现，以及相关操作的代码示例。
一、树的概念及结构
（一）树的概念
树是一种非线性的数据结构，是n(n≥0)个结点的有限集。当n=0时，称为空树。
在任意一颗非空树中应满足：
- 有且仅有一个特殊的结点，称为根结点，根节点没有前驱结点。
- 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、 … Tm,其中每一个集合Ti(1 ≤i ≤ m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
- 因此，树是递归定义的。树是一种递归的数据结构。
树作为一种逻辑结构，同时也是一种分层结构，具有以下两个特点：
- 树的根结点没有前驱，除根结点外的所有结点有且只有一个前驱
- 树中所有结点可以有零个或多个后继
注意：树形结构中，子树之间不能有交集，否则就不是树形结构。
** 一颗N个结点的数有N一1条边。**
** 树适合于表示具有层次结构的数据。**
（二）树的基本术语（无须记忆，了解即可）
节点的度： 一个节点含有的子树的个数称为该节点的度；如. 上图： A的为6
叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、1… 等节点为叶节点
非终端节点或分支节点：度不为0的节点；如上图：D、E、 F、G…等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图： B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推
树的高度或深度：树中节点的最大层次；如上图：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、1互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m(m>0)棵互不相交的树的集合称为森林；
（三）树的性质
树具有如下最基本的性质：
- 树中的结点数等于所有结点的度数之和加1.
- 度为m的树中第i层上至多有 m ( i − 1 ) m^{(i-1)} m(i−1)个结点（i≥1)。
- 高度为h的m叉树至多有 ( m h − 1 ) / ( m − 1 ) (m^h-1)/(m-1) (mh−1)/(m−1)个结点。
- 具有n个结点的m叉树的最小高度为
[
l
o
g
m
(
n
(
m
−
1
)
+
1
)
]
[log_m(n(m-1)+1)]
[logm(n(m−1)+1)]。
（四）树的表示
树结构相对线性表就比较复杂了要存储表示起来就比较麻烦了，既然保存值域， 也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。
我们这里就简单的了解其中最常用的孩子兄弟表示法。
typedef int DataType；
struct Node
{
struct Node* _firstChild1； // 第一个孩子结点
struct Node* _pNextBrother； // 指向其下一个兄弟结点
DataType _data； // 结点中的数据域
}；
二、二叉树概念及结构
一棵二叉树是结点的一个有限集合，该集合：
1.或者为空
2.由一个根节点加上两棵别称为左子树和右子树的二叉树组成
从上图可以看出：
1.二叉树不存在度大于2的结点
2.二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
注意：对于任意的二叉树都是由以下几种情况复合而成的： 
特殊的二叉树
1.满二叉树：
一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 2 k − 1 2^k-1 2k−1，则它就是满二叉树。
2.完全二叉树：
完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每个结点都与深度为K的满二叉树中编号从1至n的结点一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。
3.斜树
顾名思义，斜树一定要是斜的，但是往哪斜还是有讲究的。所有的结点都只有左子树的二叉树叫左斜树。所有结点都只有右子树的二叉树叫右斜树。这两者统称为斜树。
斜树有很明显的特点，就是每一层都只有一个结点，结点的个数与二叉树的深度相同。
有人会想，这也能叫树呀，与我们的线性表结构不是一样吗。对的，其实线性表结构就可以理解为是树的一种极其特殊的表现形式。
4.二叉排序树
左子树上所有结点的关键字均小于根结点的关键字；
右子树上的所有结点的关键字均大于根结点的关键字；
左子树和右子树又各是一颗二叉排序树。
5.平衡二叉树
树上任一结点的左子树和右子树的深度之差不超过1。
二叉树的性质
1.若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有
2
(
i
−
1
)
2^{(i-1)}
2(i−1)个结点.
2.若规定根节点的层数为1，则深度为h的二二叉树的最大结点数是
2
h
−
1.
2^h - 1.
2h−1.
3.对任何一棵二叉树，如果度为0其叶结点个数为
n
0
n_0
n0，度为2的分支结点个数为
n
2
n_2
n2,则有
n
0
=
n
2
+
1
n_0=n_2 + 1
n0=n2+1.
4.若规定根节点的层数为1，具有n个结点的满二叉树的深度，
h
=
l
o
g
2
(
n
+
1
)
h=log_2(n + 1)
h=log2(n+1). (ps:
l
o
g
2
(
n
+
1
)
log_2(n + 1)
log2(n+1)是log以2为底，n+1为对数).
5.对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有:
1.若i>0，i位置节点的双亲序号: (i-1)/2; i=0, i为根节点编号，无双亲节点.
2.若2i+1<n，左孩子序号: 2i+1， 2i+1≥n否则无左孩子.
3.若2i+2<n，右孩子序号: 2i+2，2i+2≥n否则无右孩子.
三、堆
1.完全二叉树
2.大堆：树任何一个父亲都大于或等于孩子
小堆：树任何一个父亲都小于或等于孩子
应用：
- 堆排序–O(N*logN)
- topk
- 优先级队列
堆的实现-顺序存储结构
顺序存储结构和链式结构。
这里我们使用顺序存储结构，即使用数组来实现。
void AdjustUp(HPDataType* a, int child)//向上调整
{
int parent = (child - 1) / 2;
while (child>0)//走到根终止
{
if (a[child] < a[parent]) //小堆
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else {
break;
}
}
}
void HeapPush(HP* php, HPDataType x)
{
assert(php);
if (php->size == php->capacity)
{
int newCapacity = php->capacity == 0 ? 4: php->capacity * 2;
HPDataType* tmp = (HPDataType*)realloc(php->a,newCapacity*sizeof(HPDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
php->a = tmp;
php->capacity = newCapacity;
}
php->a[php->size] = x;
php->size++;
AdjustUp(php->a,php->size-1);
}
void AdjustDown(HPDataType* a, int size, int parent)//向下调整 小堆
{
int child = parent * 2 + 1;
while ( child< size)
{
if (child + 1 < size && a[child + 1] < a[child])//注意小堆和小的比较，大堆和大的比较
{
++child;
}
// 大堆，当a[child]>a[parent]时，交换
if (a[child] < a[parent]) // 小堆，当a[child]<a[parent]时，交换
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapPop(HP* php)//删除根结点元素，向下调整算法来调整
{
assert(php);
assert(!HeapEmpty(php));
Swap(&php->a[0], &php->a[php->size]);
php->size--;
AdjustDown(php->a,php->size,0);
}
小堆的实现-代码
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int HPDataType;
typedef struct Heap//堆的实现使用数组
{
HPDataType* a;
int size;
int capacity;
}HP;
void AdjustUp(HPDataType* a, int child);//向上调整
void AdjustDown(HPDataType* a, int size, int parent);//向下调整 小堆
void HeapInit(HP* php);
void HeapDestory(HP* php);
void HeapPush(HP* php, HPDataType x);//本代码以小堆为示范
void HeapPop(HP* php);
HPDataType HeapTop(HP* php);
bool HeapEmpty(HP* php);
int HeapSize(HP* php);
#define _CRT_SECURE_NO_WARNINGS
#include "Heap.h"
void HeapInit(HP* php)
{
assert(php);
php->a = NULL;
php->size = 0;
php->capacity = 0;
}
void HeapDestory(HP* php)
{
assert(php);
free(php);
php->a = NULL;
php->size = 0;
php->capacity = 0;
}
Swap(HPDataType* p1, HPDataType* p2)
{
HPDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void AdjustUp(HPDataType* a, int child)//向上调整
{
int parent = (child - 1) / 2;
while (child>0)//走到根终止
{
if (a[child] < a[parent]) //小堆
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else {
break;
}
}
}
void HeapPush(HP* php, HPDataType x)
{
assert(php);
if (php->size == php->capacity)
{
int newCapacity = php->capacity == 0 ? 4: php->capacity * 2;
HPDataType* tmp = (HPDataType*)realloc(php->a,newCapacity*sizeof(HPDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
php->a = tmp;
php->capacity = newCapacity;
}
php->a[php->size] = x;
php->size++;
AdjustUp(php->a,php->size-1);
}
void AdjustDown(HPDataType* a, int size, int parent)//向下调整 小堆
{
int child = parent * 2 + 1;
while ( child< size)
{
if (child + 1 < size && a[child + 1] < a[child])//注意小堆和小的比较，大堆和大的比较
{
++child;
}
// 大堆，当a[child]>a[parent]时，交换
if (a[child] < a[parent]) // 小堆，当a[child]<a[parent]时，交换
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapPop(HP* php)//删除根结点元素，向下调整算法来调整
{
assert(php);
assert(!HeapEmpty(php));
swap(&php->a[0], &php->a[php->size]);
php->size--;
AdjustDown(php->a,php->size,0);
}
HPDataType HeapTop(HP* php)
{
assert(php);
assert(!HeapEmpty(php));
return php->a[0];
}
bool HeapEmpty(HP* php)
{
assert(php);
return php->size==0;
}
int HeapSize(HP* php)
{
assert(php);
return php->size;
}
#define _CRT_SECURE_NO_WARNINGS
#include "Heap.h"
void test1()
{
HP hp;
HeapInit(&hp);
int a[] = { 65,100,70,32,50,60 };
for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
{
HeapPush(&hp, a[i]);
}
HeapDestory(&hp);
}
void test2()
{
HP hp;
HeapInit(&hp);
int a[] = { 65,100,70,32,50,60 };
for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
{
HeapPush(&hp, a[i]);
}
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
printf("%d\n",top);
HeapPop(&hp);
}
// HeapPop(&hp);
HeapDestory(&hp);
}
void test3()
{
HP hp;
HeapInit(&hp);
int a[] = { 65,100,70,32,50,60 };
for (int i = 0; i < sizeof(a) / sizeof(int); ++i)
{
HeapPush(&hp, a[i]);
}
// 10:42继续
while (!HeapEmpty(&hp))
{
int top = HeapTop(&hp);
printf("%d\n", top);
HeapPop(&hp);
}
}
int main()
{
//test1();
test2();
return 0;
}
296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
