一、概念
树是⼀种⾮线性的数据结构，它是由n（n>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的
数是有一个根节点和其余排列有序的子节点组成的
结点的度：⼀个结点有⼏个孩⼦，他的度就是多少；
树的度：⼀棵树中，最⼤的结点的度称为树的度；
结点的层次：从根开始定义起，根为第1 层，根的⼦结点为第2层，以此类推；
树的⾼度或深度：树中结点的最⼤层次；
二、二叉树
在树形结构中，我们最常⽤的就是⼆叉树，⼀棵⼆叉树是结点的⼀个有限集合，该集合由⼀个根结点加上两棵别称为左⼦树和右⼦树的⼆叉树组成或者为空
1. ⼆叉树不存在度⼤于2的结点
2. ⼆叉树的⼦树有左右之分，次序不能颠倒，因此⼆叉树是有序树
满二叉树
⼆叉树的层数为K，且结点总数是2^k-1;
完全二叉树
对于深度为K的，有n个结点的⼆叉树，当且仅当其每⼀个结点都与深度为K的满⼆叉树中编号从1⾄n的结点⼀⼀对应时称之为完全⼆叉树
完全二叉树包含满二叉树
链式结构和顺序结构
1、顺序结构就是用数组来存储数据
2、链式结构
分两种
三、堆
1、概念
这里的堆不是栈区堆区中的概念，这里是指将一个集合的所有元素按完全⼆叉树的顺序存储⽅式存储
小堆：堆顶的元素是最小的，按照堆的方式将元素依次增大排列下去，只要保证每个根节点是小于它的字节点
大堆：堆顶的元素是最大的，按照堆的方式将元素依次减小排列下去
假设一个位置的节点序号为i，则他的双亲序号为(i-1)/2 ；i=0 ，i为根结点编号，⽆双亲结点；则他的左右孩子为2i+1,2i+2
堆的本质结构还是数组，因此其底层代码是数组
c
typedef int HPDataType;
typedef struct Heap
{
HPDataType* arr;
int size; //有效数据个数
int capacity; //空间大小
}HP;
//堆的初始化
void HPInit(HP* php)
{
assert(php);
php->arr = NULL;
php->size = php->capacity = 0;
}
//堆的销毁
void HPDestroy(HP* php)
{
assert(php);
if (php->arr)
free(php->arr);
php->arr = NULL;
php->size = php->capacity = 0;
}
//堆的打印
void HPPrint(HP* php)
{
for (int i = 0; i < php->size; i++)
{
printf("%d ", php->arr[i]);
}
printf("\n");
}
void Swap(int* x, int* y)
{
int tmp = *x;
*x = *y;
*y = tmp;
}
//向上调整，拿孩子跟父亲进行比较
void AdjustUp(HPDataType* arr, int child) {
int parent = (child - 1) / 2;
while (child > 0) {
//小堆： <
//大堆: >
if (arr[child] > arr[parent])
{
Swap(&arr[child], &arr[parent]);
child = parent;
parent = (child - 1) / 2;
}
else {
break;
}
}
}
//向下调整
void AdjustDown(HPDataType* arr, int parent, int n) {
int child = parent * 2 + 1;
while (child < n)
{
//大堆： <
//小堆: >
if (child + 1 < n && arr[child] < arr[child + 1])
{
child++;
}
//大堆：>
//小堆: <
if (arr[child] > arr[parent])
{
Swap(&arr[child], &arr[parent]);
parent = child;
child = parent * 2 + 1;
}
else {
break;
}
}
}
//将元素压入堆中
void HPPush(HP* php, HPDataType x) {
assert(php);
//判断空间足够
if (php->size == php->capacity)
{
//增容
int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
HPDataType* tmp = (HPDataType*)realloc(php->arr, newCapacity * sizeof(HPDataType));
if (tmp == NULL)
{
perror("realloc fail!");
exit(1);
}
php->arr = tmp;
php->capacity = newCapacity;
}
//直接插入
php->arr[php->size] = x;
//向上调整
AdjustUp(php->arr, php->size);
++php->size;
}
//判空
bool HPEmpty(HP* php)
{
assert(php);
return php->size == 0;
}
//出堆
void HPPop(HP* php)
{
assert(!HPEmpty(php));
//0 php->size-1
Swap(&php->arr[0], &php->arr[php->size - 1]);
--php->size;
//向下调整
AdjustDown(php->arr, 0, php->size);
}
//返回堆顶元素
HPDataType HPTop(HP* php)
{
assert(!HPEmpty(php));
return php->arr[0];
}
向上调整的时间复杂度为：n*log 2 （n）
向下调整的时间复杂度为：n
四、堆的应用
堆排序
c
//时间复杂度：n*log(n)
void HeapSort(int* arr, int n)
{
//向下建堆
//for (int i = (n-1-1)/2; i >= 0; i--)
//{
// AdjustDown(arr, i, n);
//}
// 建堆---向上调整
for (int i = 0; i < n; i++)
{
AdjustUp(arr, i);
}
//堆排序
//使用大堆来实现升序（就是让元素按数组的方式从小到大排列）
int end = n - 1;
while (end > 0)
{
Swap(&arr[0], &arr[end]);
AdjustDown(arr, 0, end);
end--;
}
}尽量用向下建堆的方法，时间复杂度更小
五、TOP-K问题
TOP-K问题：即求数据结合中前K个最⼤的元素或者最⼩的元素，⼀般情况下数据量都⽐较⼤
前k个最⼤的元素，则建⼩堆
前k个最⼩的元素，则建⼤堆
c
//TOPK
void CreateNDate()
{
// 造数据
int n = 100000;
srand(time(0));
const char* file = "data.txt";
FILE* fin = fopen(file, "w");
if (fin == NULL)
{
perror("fopen error");
return;
}
for (int i = 0; i < n; ++i)
{
int x = (rand() + i) % 1000000;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
void Topk()
{
int k = 0;
printf("请输入K：");
scanf("%d", &k);
const char* file = "data.txt";
FILE* fout = fopen(file, "r");
if (fout == NULL)
{
perror("fopen error");
exit(1);
}
//找最大的前K个数据，建小堆
int* minHeap = (int*)malloc(sizeof(int) * k);
if (minHeap == NULL)
{
perror("malloc fail!");
exit(2);
}
for (int i = 0; i < k; i++)
{
fscanf(fout, "%d", &minHeap[i]);
}
//建堆--向下调整建堆
for (int i = (k - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(minHeap, i, k);
}
//遍历剩下的n-k个数，跟堆顶进行比较，谁大谁入堆
//调整堆
int x = 0;
while (fscanf(fout,"%d",&x) != EOF)
{
if (x > minHeap[0])
{
minHeap[0] = x;
AdjustDown(minHeap, 0, k);
}
}
for (int i = 0; i < k; i++)
{
printf("%d ", minHeap[i]);
}
fclose(fout);
}