目录
二叉树的顺序存储结构：：
二叉树的顺序结构
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结 构存储。现实中我们通常把堆
(
一种二叉树
)
使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统
虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
堆的概念及结构：
如果有一个关键码的集合K={k0,k1,k2,...kn-1}，把它所有的元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki<=K2i+1且Ki<=K2i+2(Ki>=K2i+1且Ki>=K2i+2) i=0，1，2...，则称之为小堆(或大堆)，将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
堆的性质：
1.堆中某个节点的值总是不大于或不小于其父节点的值.
2.堆总是一颗完全二叉树.
选择题：
1.下列关键字序列为堆的是：（）
A 100,60,70,50,32,65
B 60,70,65,50,32,100
C 65,100,70,32,50,60
D 70,65,100,32,50,60
E 32,50,100,70,65,60
F 50,100,70,65,60,32
2.已知小根堆为8,15,10,21,34,16,12，删除关键字 8 之后需重建堆，在此过程中，关键字之间的比较次
数是（）。
A 1
B 2
C 3
D 4
3.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为
A(11 5 7 2 3 17)
B(11 5 7 2 17 3)
C(17 11 7 2 3 5)
D(17 11 7 5 3 2)
E(17 7 11 3 5 2)
F(17 7 11 3 2 5)
4.最小堆[0,3,2,5,7,4,6,8],在删除堆顶元素0之后，其结果是（）
A[3，2，5，7，4，6，8]
B[2，3，5，7，4，6，8]
C[2，3，4，5，7，8，6]
D[2，3，4，5，6，7，8]
选择题答案：
1.A
2.C
3.C
4.C堆的实现：
堆向下调整算法：
现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整
成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。
int array[] = {27,15,19,18,28,34,65,49,25,37};
堆的创建：
下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆。
int a[] = {1,5,3,8,7,6}; 
建堆时间复杂度的证明：
堆的插入：
先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。
堆的删除：
堆的代码实现：
Heap.h
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
void HeapPrint(HP* php)
{
for (int i = 0; i < php->size; ++i)
{
printf("%d ", php->a[i]);
}
printf("\n");
}
void AdjustUp(HPDataType* a, int child);
void AdjustDown(HPDataType* a, int n, int parent);
void HeapInit(HP* php);
void Swap(HPDataType* p1, HPDataType* p2);
void HeapDestory(HP* php);
//插入x继续保持堆形态
void HeapPush(HP* php, HPDataType x);
//删除堆顶的元素
void HeapPop(HP* php);
//返回堆顶的元素
HPDataType HeapTop(HP* php);
bool HeapEmpty(HP* php);
int HeapSize(HP* php);Heap.c
#include"Heap.h"
void HeapInit(HP* php)
{
assert(php);
php->a = NULL;
php->size = php->capacity = 0;
}
void HeapDestory(HP* php)
{
assert(php);
free(php->a);
php->a = NULL;
php->capacity = php->size = 0;
}
void Swap(HPDataType* p1, HPDataType* p2)
{
HPDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向上调整算法
//堆的向上调整次数为完全二叉树的层数，即向上调整算法(堆中插入x)的时间复杂度为O(logN)
void AdjustUp(HPDataType* a, int child)
{
int parent = (child - 1) / 2;
//不要用while(parent>=0)作继续条件 当child=0时 parent仍为0 程序陷入死循环
while (child > 0)
{
//小于改大于变大堆
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//插入x继续保持堆形态
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");
exit(-1);
}
php->a[php->size] = x;
php->size++;
AjustUp(php->a, php->size - 1);
}
}
//向下调整算法的前提条件是保证左子树右子树均为小堆
void AdjustDown(HPDataType* a, int n, int parent)
{
int minChild = parent * 2 + 1;
while (minChild < n)
{
//找出小的那个孩子
if (minChild + 1 < n && a[minChild + 1] < a[minChild])
{
minChild++;
}
if (a[minChild] < a[parent])
{
Swap(&a[minChild], &a[parent]);
parent = minChild;
minChild = parent * 2 + 1;
}
else
{
break;
}
}
}
//删除堆顶的元素——找次大或者次小
//时间复杂度为O(logN)
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);
}
//返回堆顶的元素
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;
}
堆的应用：
堆排序：
堆排序代码实现：
//堆排序—时间复杂度O(N*logN)
//利用数据结构的堆来实现堆排序的缺陷：
//1.堆的数据结构实现复杂
//2.遍历堆再依次取出来放入新的数组中，空间复杂度为O(N)
//大思路：选择排序 依次选数 从后往前排
//升序—建大堆
//降序—建小堆
//改堆排序的升序和降序只需要改变向下调整算法的大于号和小于号
//如果升序建小堆如何依次选次小的数据出来
//第一个数据排好 剩下的数据看作堆 父子关系全乱了 只能重新建堆选次小的数据 效率降低
void HeapSort(int* a, int n)
{
//建堆—向上调整建堆—O(N*logN)
/*for (int i = 1; i < n; ++i)
{
AdjustUp(a, i);
}*/
//建堆—向下调整建堆—O(N)
//保证左子树和右子树均为堆结构，从倒数第一个非叶子节点开始向下调整(最后一个节点的父亲) 直到调整到根
//为什么高效？是因为不用调整完全二叉树的最后一层且节点越多调整的次数越少
for (int i = (n - 1 - 1) / 2; i >= 0; --i)//不建议for(int i=n-1;i>=0;--i)
{
AdjustDown(a, n, i);
}
//升序
//1.建大堆
//2.第一个和最后位置交换 把最后一个不看做堆里面的 向下调整 选出次大的 后续依次类似调整
//选数
//通过向下调整算法选好n-1个数 最小的数自然就在前面了
int i = 1;
while (i < n)
{
Swap(&a[0], &a[n - i]);
AdjustDown(a, n - i, 0);
++i;
}
}
int main()
{
int a[] = { 15.1,19,25,8,34,65,4,27,7 };
HeapSort(a, sizeof(a) / sizeof(int));
for (size_t i = 0; i < sizeof(a) / sizeof(int); ++i)
{
printf("%d ",a[i]);
}
printf("\n");
return 0;
}Top-K问题：
TOP-K
问题：即求数据结合中前
K
个最大的元素或者最小的元素，一般情况下数据量都比较大
。
比如：专业前
10
名、世界
500
强、富豪榜、游戏中前
100
的活跃玩家等。
对于
Top-K
问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了
(
可能
数据都不能一下子全部加载到内存中
)
。最佳的方式就是用堆来解决，基本思路如下：
1.
用数据集合中前
K
个元素来建堆
前
k
个最大的元素，则建小堆
前
k
个最小的元素，则建大堆
2.
用剩余的
N-K
个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余
N-K
个元素依次与堆顶元素比完之后，堆中剩余的
K
个元素就是所求的前
K
个最小或者最大的元素。
//Top-K问题
void CreateDataFile(filename, N)
{
FILE* fin = fopen(filename, "w");
if (fin == NULL)
{
perror("fopen fail");
return;
}
srand(time(0));
for (int i = 0; i < N; ++i)
{
fprintf(fin, "%d ",rand());
}
fclose(fin);
}
void PrintTopK(const char* filename, int k)
{
assert(filename);
FILE* fout = fopen(filename, "r");
if (fout == NULL)
{
perror("fopen fail");
return;
}
int* minHeap = (int*)malloc(sizeof(int) * k);
if (minHeap == NULL)
{
perror("fopen fail");
return;
}
//如何读取前K个数据
for (int i = 0; i < k; ++i)
{
fscanf(fout, "%d", &minHeap[i]);
}
//建k个数小堆
for (int j = (k - 2) / 2; j >= 0; --j)
{
AdjstDown(minHeap, k, j);
}
//继续读取后N-K个
int val = 0;
while (fscanf(fout, "%d", &val) != EOF)
{
if (val > minHeap[0])
{
minHeap[0] = val;
AdjustDown(minHeap, k, 0);
}
}
for (int i = 0; i < k; ++i)
{
printf("%d", minHeap[i]);
}
free(minHeap);
fclose(fout);
}
int main()
{
const char* filename = "Data.txt";
int N = 10000;
int K = 10;
CreateDataFile(filename, N);
PrintTopK(filename, K);
return 0;
}