总结点个数为2n
假设度为0节点有a0个
假设度为1节点有a1个
假设度为2节点有a2个
…
2n = a0 + a1 + a2
求出度为2的结点个数可以用完全二叉树的性质，度为0的结点个数比度为2的结点个数多1，a0 - 1等价于度为2的结点个数，所以可以得到下面的公式
2n = a0 + a1 + a0 - 1
进一步简化
2n = 2a0 - 1 + a1
有了这个结论后，可以进一步得到下面的公式
2n = 2a0 - 1 + 1
n = a0
4.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12
思路：
由于这颗树是一个完全二叉树，想要求出这颗树的结点个数，那就把它当作一个满二叉树看待，2^h - 1就是求出一颗满叉树的结点个数，但是完全二叉树最后一层缺少的结点个数是不确定的，那就把它假设为x
假设这个完全二叉树的高度为h，那么公式就是这样的
2^h - 1 - x = 531
继续做的工作是求出x的范围【1，2^(h - 1) - 1】，这里x的范围并不能从0开始，如果从0开始那么最后一层就不存在了，并且他是一个满二叉树，就失去完全二叉树的意义了，那么最后一层结点个数的最小值也求出来了，为1
再来看最大值，满二叉树的最后一层结点个数-1得到的就是完全二叉树的最大结点个数，所以完全二叉树的结点个数最大是2^(h-1)-1
所以x的范围【1，2^(h - 1) - 1】也是可以得到验证的，最后只需要将选项套进去就可以得到最接近x范围的选项了，答案选B
2^h - 1 - x = 531
2^10 - 1 - x = 531
1024 - 1 - 531 = x
x = 492
5.一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386
已知结点个数，求出度为0的结点个数
假设度为0的结点用a0表示
假设度为1的结点用a1表示
假设度为2的结点用a2表示
767 = a0 + a1 + a2
根据前面的知识，度为0的结点个数比度为2的结点个数多1，所以计算度为2的结点个数就是a0 - 1，进一步得到下面的公式
767 = a0 + a1 + a0 - 1
度为1的结点个数a1的情况分为两种，要么是0，要么是1
所以可以进一步推断公式
767 = 2a0 + a1 - 1
左边的式子是一个奇数，2a0表示的肯定是一个偶数，那么a0必然是0，这样子2a0这个偶数减去1得到的就是奇数
768 = 2a0
a0 = 384
3.2 堆的概念及结构
堆的性质：
- Min-heap: 父节点的值小于或等于子节点的值；
- Max-heap: 父节点的值大于或等于子节点的值；
- 堆总是一棵完全二叉树。
堆的存储
在物理结构中是以数组的形式存储的，在逻辑结构上是一个完全二叉树，实际在学习和使用的时候都是从逻辑结构为出发点，在 这里会有一个规律，可以通过他的父亲计算出孩子的下标位置,这是以下公式：
计算左孩子：parent * 2 + 1
计算右孩子：parent * 2 + 2
通过孩子去计算父亲的位置：parent = (child - 1) / 2
parent这个变量表示的是树的第几层
堆排序
堆向下调整算法
- 向下调整算法的前提是：左子树和右子树恰好是小堆
- 向下调整算法的思想是将父亲跟孩子比较，如果小的孩子比父亲小，则跟父亲交换，而且把原来孩子的位置当成父亲继续往下调整，直到走到叶子结点
- 如果小的孩子比父亲大，则不需要处理，调整完成，整个树已经是小堆
void AdjustDown(int \*arr,int n, int parent)
{
//默认左孩子小
int child = parent \* 2 + 1;
while (child < n)
{
//如果右孩子比左孩子小，那就走到右孩子
if (arr[child + 1] < arr[child])
{
++child;
}
//比较父子之间的大小关系，小的往上换
if ( arr[child] < arr[parent] )
{
Swap(&arr[child],&arr[parent]);
//将原来孩子的位置给父亲，继续算出新的孩子位置
parent = child;
child = parent \* 2 + 1;
}
//已经是小堆了，不需要处理
else
{
break;
}
}
}
面对左右子树不是小堆的情况下，向下调整算法的优化
实现思路：如果左右子树不是堆的情况，使用向下调整算法肯定没有规律了，但是可以换一个角度考虑，从最后一个父亲位置开始把它作为一个子树，对它进行向下调整后这个子树就是小堆了，紧接着找到第二个子树依次…向下调整，最后左子树与右子树之间整体一调整就是一个堆了，已经用序列号标记好，将这几个圈起来的看作是一个子树，对每一个子树向下调整，会得到一个小堆，整体一调整会成一个大堆
代码实现：
//n-1是最后一个下标的位置，
//已知孩子位置求父亲位置的公式是parent = (child - 1) / 2
for(int i = (n - 1 - 1) / 2; i >= 0 ; i--)
{
AdjustDown(arr,n,i);
}
建堆时间复杂度分析
堆排序的思考，为什么排升序要建大堆
1、堆排序要建堆，建堆时间复杂度：O(N)
2、建好堆了选数，堆排序的时间复杂度：O(N log N)
假设排升序建小堆，选出最小的数放到第一个位置，紧接着向下调整选出次小的
结论：堆排序排升序建小堆是没有意义的
那建大堆呢？
从最后一个父亲位置开始把它作为一个子树，对它进行向下调整后这个子树就是大堆了，紧接着找到第二个子树依次…向下调整，最后左子树与右子树之间整体一调整就是一个大堆了
建好大堆后再堆排序
利用堆删除思想来进行排序
思想：
先选出最大的和最后一个元素交换，再向下调整，再不把最后一个数看成是堆里面的，紧接着选出次大的，和最后一个元素交换，再向下调整，不把最后一个元素看作是堆里面的，依次循环直到只剩最后一个元素了，就可以认为是有序的了
反之如果是排降序呢？那就是建小堆了，选出最小的数与最后一个元素交换，再向下调整，紧接着不把它看作是堆里面的，再选次小，交换，向下调整，不看做堆元素，反反复复直到只剩最后一个元素就可以是降序了
结论
升序：建大堆，从它的效率上来看已经很优了。
降序：建小堆
堆排序代码实现
//交换
void Swap(int \*data1,int \*data2)
{
int tmp = \*data1;
\*data1 = \*data2;
\*data2 = tmp;
}
//打印
void print(int \*arr,int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ",arr[i]);
}
}
void AdjustDown(int \*arr, int n, int parent)
{
int child = parent \* 2 + 1;
while (child < n)
{
//右孩子比左孩子大
if (child + 1 < n && arr[child + 1] > arr[child])
{
child++;
}
//孩子大于父亲就交换，通过孩子的位置去计算父亲的位置，再求父亲位置
else if (arr[child] > arr[parent])
{
Swap(&arr[child],&arr[parent]);
parent = child;
child = parent \* 2 + 1;
}
//已经是小堆了
else
{
break;
}
}
}
void SortHeap(int \*arr, int n)
{
//建堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(arr, n, i);
}
//堆排
int end = n - 1;
//end > 0，不需要end >= 0 ,只剩最后一个元素就可以看作是有序的了
while (end > 0)
{
Swap(&arr[end],&arr[0]);
AdjustDown(arr,end,0);
//堆删除思想
end--;
}
}
int main()
{
int arr[10] = { 27,15,19,18,28,34,65,49,25,37 };
int n = sizeof(arr) / sizeof(arr[0]);
SortHeap(arr, n);
print(arr,n);
return 0;
}
堆实现
接口声明
#pragma once
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>
#include<stdlib.h>
#include<memory.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType \*a;
int size;
int capacity;
}Heap;
//堆的初始化
void HeapInit(Heap \*php, HPDataType \*a, int n);
//打印
void Heapprint(Heap \*php);
//销毁
void HeapDestroy(Heap \*php);
//向下调整
void AdjustDown(int \*arr, int n, int parent);
//向上调整
void AdjustUp(int \*a, int child);
//堆排序
void SortHeap(int \*arr, int n);
//插入
void HeapPush(Heap \*php,int data);
//删除数据
void HeapPop(Heap \*php);
// 取堆顶的数据
HPDataType HeapTop(Heap\* php);
// 堆的数据个数
int HeapSize(Heap\* php);
// 堆的判空
int HeapEmpty(Heap\* php);
接口实现
#include"Heap.h"
void Swap(int \*data1, int \*data2)
{
int tmp = \*data1;
\*data1 = \*data2;
\*data2 = tmp;
}
//建堆
void AdjustDown(int \*arr, int n, int parent)
{
int child = parent \* 2 + 1;
while (child < n)
{
if (child + 1 < n && arr[child + 1] > arr[child])
{
child++;
}
//交换孩子和父亲
if (arr[child] > arr[parent])
{
Swap(&arr[child], &arr[parent]);
parent = child;
child = parent \* 2 + 1;
}
else
{
break;
}
}
}
//堆排序
void SortHeap(int \*arr, int n)
{
//建堆，从最后一个父节点开始向下调整
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(arr, n, i);
}
//堆排
int end = n - 1;
while (end > 0)
{
Swap(&arr[end], &arr[0]);
AdjustDown(arr, end, 0);
end--;
}
}
//堆的初始化
void HeapInit(Heap \*php, HPDataType \*a, int n)
{
assert(php);
php->a = (HPDataType \*)malloc(sizeof(HPDataType) \* n);
if (php->a == NULL)
{
perror("HeapInit::malloc");
exit(-1);
}
php->size = php->capacity = n;
//初始化
memcpy(php->a,a,sizeof(HPDataType) \* n);
//建堆
int i = 0;
for (i = (php->size - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(php->a,php->size,i);
}
}
//打印
void Heapprint(Heap \*php)
{
assert(php);
int i = 0;
int k = 1;
int pos = 0;
for (i = 0; i < php->size; i++)
{
printf("%d ", php->a[i]);
if (pos % k == 0)
{
printf("\n");
k \*= 2;
pos = 0;
}
pos++;
}
printf("\n");
}
//销毁
void HeapDestroy(Heap \*php)
{
assert(php);
free(php->a);
php->a = NULL;
php->capacity = php->size = 0;
}
//向上调整
void AdjustUp(int \*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(Heap \*php, int data)
{
assert(php);
//插入值需要考虑库容
if (php->size == php->capacity)
{
php->a = realloc(php->a, sizeof(int) \* php->capacity \* 2);
if (php->a == NULL)
{
perror("HeapInsrt::malloc");
exit(-1);
}
//二倍增长
php->capacity \*= 2;
}
//尾插
php->a[php->size] = data;
php->size++;
//为了不改变堆的结构，向上调整
AdjustUp(php->a,php->size - 1);
}
//删除数据
void HeapPop(Heap \*php)
{
assert(php);
assert(php->size > 0);
//交换第一个和最后一个，删除元素，向下调整
int end = php->size - 1;
Swap(&php->a[0], &php->a[end]);
--php->size;
AdjustDown(php->a, php->size, 0);
}
// 取堆顶的数据
HPDataType HeapTop(Heap\* php)
{
assert(php);
assert(!HeapEmpty(php));
return php->a[0];
}
// 堆的数据个数
int HeapSize(Heap\* php)
{
assert(php);
return php->size;
}
// 堆的判空
int HeapEmpty(Heap\* php)
{
assert(php);
return php->size == 0 ? true : false;
}
初始化
//堆的初始化
void HeapInit(Heap \*php, HPDataType \*a, int n)
{
assert(php);
php->a = (HPDataType \*)malloc(sizeof(HPDataType) \* n);
if (php->a == NULL)
{
perror("HeapInit::malloc");
exit(-1);
}
php->size = php->capacity = n;
//初始化
memcpy(php->a,a,sizeof(HPDataType) \* n);
//建堆
int i = 0;
for (i = (php->size - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(php->a,php->size,i);
}
}
初始化堆的过程其实就是一个建堆的过程，用数组中可利用的元素完成建堆，有了这个堆结构后才能做后面的事情
打印
//打印
void Heapprint(Heap \*php)
{
assert(php);
int i = 0;
int k = 1;
int pos = 0;
for (i = 0; i < php->size; i++)
{
printf("%d ", php->a[i]);
if (pos % k == 0)
{
printf("\n");
k \*= 2;
pos = 0;
}
pos++;
}
printf("\n");
}
遍历一遍堆，为了更醒目地呈现堆结构，这里将代码控制了一下
销毁
//销毁
void HeapDestroy(Heap \*php)
{
assert(php);
free(php->a);
php->a = NULL;
php->capacity = php->size = 0;
}
释放动态申请的空间
向下调整建堆
//建堆
void AdjustDown(int \*arr, int n, int parent)
{
int child = parent \* 2 + 1;
while (child < n)
{
//选出左右孩子的大的那一个
if (child + 1 < n && arr[child + 1] > arr[child])
{
child++;
}
//交换孩子和父亲
if (arr[child] > arr[parent])
{
Swap(&arr[child], &arr[parent]);
parent = child;
child = parent \* 2 + 1;
}
//已经是堆了就不需要再调整
else
{
break;
}
}
}
选出左右孩子大的那一个跟父亲交换，孩子的位置给父亲继续计算下一个孩子的位置，这里建的是大堆
向上调整
void AdjustUp(int \*a,int child)
{
int parent = (child - 1) / 2;
while (parent >= 0)
{
if (a[child] > a[parent])
{
Swap(&a[child],&a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
如果插入一个值后，需要调整推荐的是向上调整方式，如果是重新建堆的话效率太低了，而向上调整算法只需要调整一条路径的值，即使可以插入的值会改变原先的堆结构，但是这个算法的好处是可以不需要重新建堆
堆排序
//堆排序
void SortHeap(int \*arr, int n)
{
//建堆，从最后一个父节点开始向下调整
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(arr, n, i);
}
//堆排
int end = n - 1;
while (end > 0)
{
Swap(&arr[end], &arr[0]);
AdjustDown(arr, end, 0);
end--;
}
}
前面已经有详细的介绍了，这里就不再继续
插入值
//插入
void HeapPush(Heap \*php, int data)
{
//插入值需要考虑库容
if (php->size == php->capacity)
{
php->a = realloc(php->a, sizeof(int) \* php->capacity \* 2);
if (php->a == NULL)
{
perror("HeapInsrt::malloc");
exit(-1);
}
//二倍增长
php->capacity \*= 2;
}
//尾插
php->a[php->size] = data;
php->size++;
//为了不改变堆的结构，向上调整
AdjustUp(php->a,php->size - 1);
}
插入值后为了保证堆结构不被破坏，又希望希望不用建堆算法想效率高点，最好的方式是向上调整
删除
//删除数据
void HeapPop(Heap \*php)
{
assert(php);
assert(php->size > 0);
/
int end = php->size - 1;
Swap(&php->a[0], &php->a[end]);
--php->size;
AdjustDown(php->a, php->size, 0);
}
交换第一个和最后一个，删除元素，向下调整
取数据
// 取堆顶的数据
HPDataType HeapTop(Heap\* php)
{
## 写在最后
**在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。**
需要完整版PDF学习资源私我
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
扫一扫
4539
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
