【数据结构】（堆）Top-k|堆排序

目录

概念：

堆的实现?

构建

初始化

销毁

插入元素

往上调整?

删除堆顶元素?

往下调整?

返回堆顶元素?

?返回有效个数

是否为空

?堆排序

?Top-k问题

?编辑?创建数据

堆top-k

---

概念：

堆是将数据按照完全二叉树存储方式存储到一维数组中；

堆分为大堆和小堆：

大堆：父结点大于等于孩子结点；

小堆：父结点小于等于孩子结点；

父结点与（左右）孩子结点关系：

1.父结点 = （孩子结点-1）/2；

2.左结点= （父结点*2）+1；

????????右结点= （父结点*2）+2；

堆的实现?

堆的逻辑结构是完全二叉树，物理结构是一维数组存储；

而独特的结点关系，堆排序也是一种选择排序，

构建

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* parr;
	int size;		//存储的有效数据个数
	int capacity;	//容量
}Heap;
//	用数组存储    

初始化

//堆的初始化
void HeapInit(Heap* php)
{
	assert(php);
	php->parr = NULL;
	php->size = 0;
	php->capacity = 0;
}

销毁

//堆的销毁
void HeapDestroy(Heap* php)
{
	assert(php);
	free(php->parr);
	php->parr = NULL;
	php->size = php->capacity = 0;
	free(php);
	php = NULL;
}

插入元素

因为堆分为两类，在数据插入时，需要选择适应的调整；

以小堆来说：当插入一个新元素时，插入到堆尾，与父结点比较，相应的往上调整

//堆的插入元素
void HeapPush(Heap* php, HPDataType x)
{
	assert(php);
	//检查容量
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* newparr = (HPDataType*)realloc(php->parr, sizeof(HPDataType) * newcapacity);
		if (newparr == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		php->capacity = newcapacity;
		php->parr = newparr;
	}
	php->parr[php->size] = x;
	php->size++;
	
	//小堆
	//向上调整
	AdjustUp(php->parr, php->size - 1);
}

往上调整?

当插入一个新元素，按照孩子和父结点之间的关系进行比较，交换两结点数据，直到满足堆的性质?

//向上调整
void AdjustUp(HPDataType* parr,int size)
{
	int child = size;
	int parent = (child - 1) / 2;
	//小堆=> 父结点<=孩子结点
	while (child>0)
	{
		if (parr[child] < parr[parent])
		{
			//交换数据
			Swap(&parr[child], &parr[parent]);
			child = parent;        //更新结点位置
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

删除堆顶元素?

1.将堆顶元素和尾部元素互换位置；

2.将此刻不符合规定的堆顶元素往下调整至相应位置；?

// 删除堆顶（根节点）
void HeapPop(Heap* php)
{
	assert(php);
	//1.堆顶元素和尾部元素置换位置
	Swap(&php->parr[0], &php->parr[php->size - 1]);
	php->size--;	//删掉交换后的堆顶元素

	//2.将新站顶元素找到相应位置
	//向下调整
	AdjustDown(php->parr,php->size,0);
}

往下调整?

堆顶元素与其孩子结点比较，如何找到较大（较小）的孩子？

可以假设法：假设较大（较小）的孩子为左孩子，然后验证假设；

//向下调整
void AdjustDown(HPDataType* parr,int size,int parent)
{
	int child = (parent * 2) + 1;
	while (child<size)	//
	{
		//假设左孩子为较小值
		if (child+1<size && parr[child + 1] < parr[child])	//验证假设
		{
			++child;	//说明右孩子更小，更换孩子位置
		}
		//检查是否不符合堆排序结构 
		if (parr[parent] > parr[child])
		{
			Swap(&parr[parent], &parr[child]);
			//往下更新父结点 孩子结点位置
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

返回堆顶元素?

起始值为0；

//返回堆顶元素
HPDataType HeapTop(Heap* php)
{
	assert(php);
	assert(php->size > 0);
	return php->parr[0];
}

?返回有效个数

注意，构建堆的时候，size是最后一个元素的下一个；

//返回堆内有效数据个数
size_t HeapSize(Heap* php)
{
	assert(php);

	return php->size;	//数组下标0开始
}

是否为空

//判断堆是否为空
bool HeapEmpty(Heap* php)
{
	return php->size == 0;
}

?堆排序

以上是一些堆的简单功能实现；算不上真正的堆排序；

假设给定一串数字，4,6,2,1,5,8,2,9；如何将其排序？比如升序；

1. 建立一个大堆；
2. 将堆顶元素与堆尾元素互换，且将遍历堆的范围-1，保证其想要的值保持不动；
3. 将此刻不符合规定的堆顶往下调整，找到次大的值；重复步骤2；

其实相当于第一个元素默认是堆，后面的进行遍历调整；?

//排序,升序
void HeapSort(int* parr, int n)
{
	//1.建立大堆
	for (int i = 1;i < n; i++)
	{
		justUp(parr, i);
	}

	//2.堆顶元素与堆尾元素互换，然后将堆size-1（指只需要遍历到的位置）
	int end = n - 1;
	while (end>0)
	{
		//堆顶和堆尾 元素呼唤
		Swap(&parr[0], &parr[end]);
		//往下调整
		justDown(parr,end,0);
		end--;
	}
}

也有其他思路；

我们从下面子树往上遍历，而内部调整时往下调整

?n-1是最后结点下标值，（结点-1）/2 可以得到该结点的父结点，从父结点往下调整；

for (int i = (n-1-1)/2; i >= 0; --i)
	{
		AdjustDown(parr, n, i);
	}

?Top-k问题

在排序的基础上，如果这个数很大呢，比如一百万个数，要找到前k个较大值；

此刻建堆排序显然不合适；

1.读取前K个值，建立其小堆；

2.依次读取后面的值，与堆顶比较：如果比堆顶大，替换堆顶进堆，再往下调整；

?创建数据

//tok-k 问题
//创建一千万的数据
void CreateNode()
{
	// 造数据
	int n = 10000000;
	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) % 10000000;	//+i是 因为随机数产生只有三万个，加上i可以大大减少重复值
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

堆top-k

开辟K个数的空间（动态数组）；

建立K个数的小堆；

读取文件中值，遍历与堆顶比较，

void HeapTok(const char* file,int k)
{
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	//开辟K个数的空间
	int* minheap = (int*)malloc(sizeof(int) * k);
	if (minheap == NULL)
	{
		perror("malloc error");
		return;
	}

	//建立K个数的小堆
	for (int i = 0; i < k; i++)
	{
		//从文件流中 读取数据存到 开辟的空间中
		fscanf(fout,"%d", &minheap[i]);
		//往上调整
		AdjustUp(minheap, i);
	}

	//遍历文件数据 
	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)	
	{
		if (x > minheap[0])
		{
			minheap[0] = x;
			//往下调
			AdjustDown(minheap, k, 0);
		}
	}

	//打印tok
	for (int i = 0; i < k; i++)
	{
		printf("%d ", minheap[i]);
	}
	free(minheap);
	fclose(fout);
}