目录
二叉树
二叉树的存储结构
逻辑结构：想象出来的
物理结构：实实在在在物理上的存储
完全二叉树的存储方式
完全二叉树的存储方式为数组存储。
如果为非完全二叉树会浪费很多空间。
二叉树中父子下标关系
parent=(child-1)/2
left child = parent*2 +1
right child =parent*2+2
二叉树的性质
-
若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有$2^{(i-1)}$ 个结点.
-
若规定根结点的层数为1，则深度为h的二叉树的最大结点数是$2^h-1$.
-
对任何一棵二叉树, 如果度为0其叶结点个数为 $n_0$, 度为2的分支结点个数为 $n_2$,则有$n_0$＝$n_2$＋1
-
若规定根结点的层数为1，具有n个结点的满二叉树的深度，h=$log_2(n+1)$. (ps：$log_2(n+1)$是log以2为底，n+1为对数)
-
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从0开始编号，则对于序号为i的结点有：
-
若i>0，i位置结点的双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
-
若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
-
若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子
-
堆
堆的概念
它的所有元素按完全二叉树的顺序存储方式存储
将根节点最大的堆叫做大根堆（树中所有父亲都大于孩子）
根节点最小的堆叫做小根堆 （树中所有父亲都小于孩子）
堆的实现
1.堆的结构
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;2.堆的初始化
void HeapInit(HP* php)
{
assert(php);
php->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
if (php->a == NULL)
{
perror("malloc fail");
return NULL;
}
php->size = 0;//1.指向队尾的下一个元素 2.为队中元素的个数
php->capacity = 4;
}3.堆的销毁
void HeapDestroy(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->size = php->capacity = 0;
}4.取堆顶数据
HPDataType HeapTop(HP* php)
{
assert(php);
return php->a[0];
}6.堆的大小
int HeapSize(HP* php)
{
assert(php);
return php->size;
}7.堆的判空
bool HeapEmpty(HP* php)
{
assert(php);
return php->size == 0;
}8.堆的插入
代码实现：
void AdjustUp(HPDataType* a, int child)
{
int parent = (child - 1) / 2;
//while (parent >= 0)
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)
{
HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * php->capacity * 2);
if (tmp == NULL)
{
perror("realloc fail");
return;
}
php->a = tmp;
php->capacity *= 2;
}
php->a[php->size] = x;
php->size++;
AdjustUp(php->a, php->size - 1);
}插入步骤：先向堆里插入一个数，在用向上调整算法。
向上调整算法：
1.让插入的数当做子节点，拿去和父节点比较，如果子节点大于父节点（上述代码演示的是大根堆的情况下），那么交换父子节点。
2.当孩子节点不大于0时就跳出循环。
Q:为什么此处将parent>=0改为child>0
A:parent>=0可以运行，但是不好
当child==0时，child-1为负数，
但parent为整形，所以parent==0,始终满足进入循环的条件
Q:那为什么仍旧可以运行而不是进入死循环
A:当再次进入的时候child==parent
不满足a[child]>a[parent],break
9.堆的删除
void AdjustDown(HPDataType* a, int n, int parent)//n为元素个数
{
int child = parent * 2 + 1;
while (child < n)
{
// 选出左右孩子中大的那一个
if (child + 1 < n && a[child + 1] > a[child])
{
++child;
}
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
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 - 1]);
php->size--;
AdjustDown(php->a, php->size, 0);
}堆的删除：
1.先将堆顶元素和最后一个元素进行交换
2.删除堆中最后一个元素
3.堆顶用向下调整算法直到满足堆的特性为止
Q:挪动删除是否可行：X
如上图，为挪动删除
两个弊端：1.效率低下
2.父子关系全乱了
10.交换两个堆
void Swap(HPDataType* a, HPDataType* b)
{
HPDataType tmp = *a;
*a = *b;
*b = tmp;
}建堆
1.建堆的定义
建堆是指将一个无序的数组或完全二叉树调整成为一个堆的过程。
2.向上调整建堆的时间复杂度
将数组的第一个元素看做堆顶，后面的元素尾插，再向上调整
3.向下调整建堆的时间复杂度
从第一个非叶子节点开始调整，向下调整。
因此通常用向下调整法建堆
建堆的代码实现
void HeapInitArray(HP* php, int* a, int n)
{
assert(php);
php->a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
if (php->a == NULL)
{
perror("malloc fail");
return NULL;
}
php->a = a;
php->size = 0;
php->capacity = 4;
//建堆
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(php->a, php->size, i);
}
}堆排序
堆排序的定义
堆排序是一种基于堆的排序算法。
初始时，将待排序的无序数组（排序的是数组）构建为一个堆。构建为大根堆或者小根堆。
交换堆顶元素和堆的最后一个节点，然后将堆的大小减一。
对交换后的堆进行向下调整，重新满足堆的性质。
重复上述步骤，直到堆的大小为1
此时得到的是一个有序的堆（即底层数组是有序的，得到了升序或者降序排列的数组）（在堆上的体现就是左右节点之间也有大小关系）
升序——建小根堆
降序——建大根堆
代码实现：
//堆排序
void HeapSort(HPDataType* a, int n)//n为数组中元素的个数
{
//向下排序建大根堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
//实现数组的降序
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}TOP_K
void PrintTopK(HPDataType* a, int n, int k)
{
HeapSort(a, n);
for (int i = 0; i < k; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
扫一扫
3756
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
