二叉树（二）

一、二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆（一种二叉树）使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

二、堆的概念及结构

堆是完全二叉树，用数组存储。

大堆 ：完全二叉树；任何一个父亲大于等于孩子（兄弟之间没有规定大小关系）；根是最大的。

小堆 ：完全二叉树；任何一个父亲小于等于孩子（兄弟之间没有规定大小关系）；根是最小的。

 三、堆的实现

1.向下调整算法

给出一个数组，逻辑上看成一棵完全二叉树。我们通过从根结点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

int array[] = {27,15,19,18,28,34,65,49,25,37}; 

2.堆的创建

给出一个数组，这个数组在逻辑上可以看成完全二叉树，但是还不是堆。从倒数第一个非叶子节点的子树开始，一直调整到根节点的树，就可以调整成堆。

int a[] = {1,5,3,8,7,6}; 

3. 调整建堆时间复杂度

堆是完全二叉树，满二叉树也是完全二叉树，这里使用满二叉树来证明（时间复杂度看的是近似值）：

 4.堆的插入

先插入一个10到数组的尾，再进行向上调整算法，直到满足堆。

5.堆的删除

若挪动覆盖删除堆顶数据，关系就乱了，兄弟变父子，叔侄变兄弟……

删除堆是删除堆顶的数据，将堆顶数据和最后一个数据交换，然后删除数组的最后一个数据，再进行向下调整算法。

6.堆的代码实现 

Heap.h文件：

#pragma once
#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 HPInit(HP* php);
//销毁
void HPDestroy(HP* php);
//堆的插入
void HPPush(HP* php, HPDataType x);
//堆的删除
void HPPop(HP* php);
//取堆顶的数据
HPDataType HPTop(HP* php);
//堆的判空
bool HPEmpty(HP* php);

Heap.c文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
//初始化
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}
//销毁
void HPDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}
//交换
void 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)//while (parent >= 0)，这样写也能运行，但是这里存在bug：
                     //当parent=0时也会进入循环，parent=child=0，
                     //虽然parent和child都等于0，但是a[child] < a[parent]不成立，
                     //直接break，也能运行
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
//插入
void HPPush(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 n, int parent)
{
	// 先假设左孩子小
	int child = parent * 2 + 1;
	while (child < n)  // 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 HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}
//取栈顶数据
HPDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}
//判空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

Test.c文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
void TestHeap1()
{
	int a[] = { 4,2,8,1,5,6,9,7,3,23,55 };
	HP hp;
	HPInit(&hp);
	for (size_t i = 0; i < sizeof(a) / sizeof(int); i++)
	{
		HPPush(&hp, a[i]);
	}

	int i = 0;
	while (!HPEmpty(&hp))
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);
	}
	printf("\n");
	HPDestroy(&hp);
}
int main()
{
	TestHeap1();
	return 0;
}

四、堆排序

堆排序是利用堆的思想进行排序，分为两个步骤：

①建堆：升序建大堆，降序建小堆（若降序建大堆，关系全乱了）

②利用堆删除思想进行排序

建堆和堆删除都用到了向下调整，因此需要掌握向下调整，就可以完成堆排序。

#include<stdio.h>
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustDown(int* a, int n, int parent)
{
	// 先假设左孩子小
	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 HeapSort(int* a, int 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;
	}
}
void TestHeap2()
{
	int a[] = { 4,2,8,1,5,6,7,9,3 };
	HeapSort(a, sizeof(a) / sizeof(int));
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		printf("%d ", a[i]);
	}
}
int main()
{
	TestHeap2();
	return 0;
}

五、TOP-K问题

求数据中前K个最大或最小的元素，一般情况下数据量都比较大。

对于TOP-K问题，最简单最直接的方式就是排序，但是如果数据量非常大，排序就不可取了（数据不可能一下子全部加载到内存中）。

最佳的方式是用堆来解决：

①数据集合中前K个元素建堆：前K个最大的元素建小堆，前K个最小的元素建大堆——时间复杂度O(K)；

②剩余数据依次和堆顶数据比较，不满足就替换堆顶数据（覆盖根位置，然后向下调整）——时间复杂度O(log K*(N-K))。

合计：O(N)

void CreateNDate()
{
	// 造数据
	int n = 10000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}
	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 1000000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
}
void PrintTopK(int k)
{
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}
	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc error");
		return;
	}
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &kminheap[i]);
	}
    // 建小堆
	for (int i = (k-1-1)/2; i >= 0; i--)
	{
		AdjustDown(kminheap, k, i);
	}
	int val = 0;
	while (!feof(fout))
	{
		fscanf(fout, "%d", &val);
		if (val > kminheap[0])
		{
			kminheap[0] = val;
			AdjustDown(kminheap, k, 0);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}