堆排序&线性建堆

描述

堆排序是一种基于二叉堆数据结构的排序算法。它的主要思想是将待排序的元素构建成一个二叉堆，然后通过不断地将堆顶元素（即最大或最小元素）与堆的最后一个元素交换，并重新调整堆，使得剩余元素重新构成一个堆。通过重复这个过程，最终得到一个有序的序列。

思考

一、建堆
（1）普通建堆
将原数组的元素依次插入堆尾，进行向上调整，时间复杂度为O(nlogn)
（2）线性建堆
堆中的节点数量是 n，树高是 log2​n。其中，根节点可能需要向下调整 log2​n 次，根节点下面的 2 个子节点，可能需要向下调整 log2​n−1 次，第三层的 4 个子节点，可能需要调整 log2​n−2 次。
sum=1×log2​n+2×(log2​n−1)+4×(log2​n−2)…+(n/4)×1
2sum= 2×log2​n +4×(log2​n−1)…+(n/4)×2+(n/2)×1
2sum−sum=2+4+8+…+(n/4)+(n/2)−log2​n=(n/2)-1-log2n
时间复杂度为O(n)

二、排序
将堆顶元素与堆末元素进行调换，再对堆顶元素进行向下调整。

代码实现

测试程序：

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<time.h>

#define FATHER(i) ((i)/2)
#define LEFT(i) (i*2)
#define RIGHT(i) (i*2+1)
#define ROOT 1
#define TEST(func,arr,n){ \
	printf("TEST:%s\t",#func);\
	int *temp=(int*)malloc(sizeof(int)*n);\
	memcpy(temp,arr,sizeof(int)*n);\
	long long begin=clock();\
	func(temp, n); \
	long long end=clock();\
	if(check(temp,n)){\
		printf("OK\t");\
		printf("%lld ms\n",(end-begin)*1000/CLOCKS_PER_SEC);\
	}\
	else{\
		printf("FAIL\n");\
	}\
	free(temp);\
}\
bool check(int* arr, int n) {
	for (int i = 1; i < n; ++i) {
		if (arr[i] > arr[i - 1]) return false;
	}
	return true;
}
//随机生成数组
int* getRandData(int n) {
	int* arr = (int*)malloc(sizeof(int) * n);
	for (int i = 0; i < n; ++i) arr[i] = rand() % 10000000;
	return arr;
}

两种排序程序：

//堆排序
void down_update(int* data, int i, int n);
void heap_sort(int* data, int n) {
	for (int i = n; i >= 2; --i) {
		int tmp = data[i];
		data[i] = data[ROOT];
		down_update(data, ROOT, i-1);
	}
}

//向上调整
inline void up_update(int* data, int i) {
	while (i > 1 && data[i] > data[FATHER(i)]) {
		int tmp = data[i];
		data[i] = data[FATHER(i)];
		data[FATHER(i)] = tmp;
	}
}
//向下调整
inline void down_update(int* data, int i,int n) {
	while (LEFT(i) <= n) {
		int l = LEFT(i), r = RIGHT(i), index = i;
		if (data[l] > data[index]) index = l;
		if (r<=n && data[r] > data[index]) index = r;
		if (index == i) return;
		int tmp = data[index];
		data[index] = data[i];
		data[i] = tmp;
	}
}
//普通建堆
inline void normal_heap_build(int* data, int n) {
	for (int i = 2; i <= n; ++i) {
		up_update(data, i);
	}
}
//线性建堆
inline void linear_heap_build(int* data, int n) {
	for (int i = n / 2; i >= 1; --i) {
		down_update(data, i,n);
	}
}

//应用线性建堆的堆排序
void linear_heap(int* arr, int n) {
	int* data = arr - 1;
	linear_heap_build(arr, n);
	heap_sort(data, n);
}
//应用普通建堆的堆排序
void normal_heap(int* arr,int n) {
	int* data = arr - 1;
	normal_heap_build(arr, n);
	heap_sort(data, n);
}


int main() {
	srand(time(0));
    #define MAX_N 100000000
	int* arr = getRandData(MAX_N);
	TEST(normal_heap, arr, MAX_N);
	TEST(linear_heap, arr, MAX_N);
	return 0;
}

运行结果：

可见线性建堆比普通建堆速度快