C语言：堆与完全二叉树与优先队列

堆与完全二叉树区别：堆分为大顶堆和小顶堆，即在满足完全二叉树的条件下，还要满足（根，左孩子， 右孩子）这个三元组始终满足根最大or最小的性质。

接下来，以大顶堆为例，阐述关于堆的一些操作：
查找最值：根始终为最大值，根的左右孩子中一定有第二大值，但第三大值就不确定了；
插入值：首先为了满足完全二叉树的结构，将值添加在最后面，然后沿着该节点到根的这条路劲上，以从小到大的原则，进行换位调整（有点冒泡的意思），直到整条路径上的元素为有序的；
弹出值：将栈顶弹出（类似队列），然后为了维护完全二叉树节构，将树最后元素交换到根，然后自上而下检索三元组是否满足要求，若不符合，继续将根结点与左右子树中的最值交换；
总体来说，堆是一个 插入尾部，弹出头部 的结构，这符合FIFO（队列）的性质，并且弹出的值有最值性质，所以又称该结构为优先队列。

由于堆的优先队列性质，可以通过堆来实现堆排序。
排序过程以大顶堆为例，每次堆顶弹出当前队列最大值，并将队尾元素交换到堆顶，然后检查有序性。那么如果利用队列原本的存储空间，可以将每一次弹出操作，视为队首与队尾的一次交换，每次交换后，队列元素数量减一，这样，弹出的最大值、次大值…就会被安放在数组的n-1、n-2、…位置上，最后整个数组是按从小到大排序的。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define swap(a, b){\
__typeof(a) __temp = a;\
a = b;\
b = __temp;\
}

typedef struct priority_queue{
	int *data;
	int cnt, size;
}priority_queue;

priority_queue *init(int n){
	priority_queue *q = (priority_queue *)malloc(sizeof(priority_queue));
	q->data = (int *)malloc(sizeof(int) * (n + 1));
	q->cnt = 0;
	q->size = n;
	return q;
}

int empty(priority_queue *q){
	return q->cnt == 0;
}

int top(priority_queue *q){
	return q->data[1];
}

int push(priority_queue *q, int val){
	if (q == NULL) return 0;
	if (q->cnt == q->size) return 0;
	q->data[++(q->cnt)] = val;
	//q->cnt += 1;
	//q->data[q->cnt] = val;
	//printf("q->cnt = %d\n", q->cnt);
	int ind = q->cnt;
	//父节点不为零（存在，注意根节点为1
	while(ind >> 1 && q->data[ind] > q->data[ind >> 1]){
		//因为父节点是一定大于左右子节点的，所以比父节点大意味着一定比兄弟节点大
		//因此交换一定能保证父节点的三元组成立
		//printf("swap child:%d and father:%d \n", q->data[ind], q->data[ind >> 1]);
		swap(q->data[ind], q->data[ind >> 1]);
		ind >>= 1;
	}
	return 1;
}

//弹出元素在队尾后面
int pop(priority_queue *q){
	if (q == NULL) return 0;
	if (empty(q)) return 0;
	q->data[1] = q->data[q->cnt--];
	int ind = 1;
	//判断左孩子是否存在
	while((ind << 1) <= q->cnt){
		int temp = ind, l = ind << 1, r = (ind << 1) | 1;
		if (q->data[temp] < q->data[l]) temp = l;
		//需要判断右孩子是否存在！
		if (r <= q->cnt && q->data[temp] < q->data[r]) temp = r;
		//没有调整，意味着顺序
		if (temp == ind) break;
		//printf("swap child:%d and father:%d \n", q->data[ind], q->data[ind >> 1]);
		swap(q->data[ind], q->data[temp]);
		ind = temp;
	}
	return 1;
}

void clear(priority_queue *q){
	if (q == NULL) return;
	free(q->data);
	free(q);
	return;
}

int main(){
	srand(time(0));
#define max_n 20
	priority_queue *q = init(max_n + 1);
	for (int i = 0; i < max_n; i++){
		int val = rand() % 100;
		if (push(q, val))
			printf("insert %d\n", val);
		//push(q, val);
	}
	printf("q:");
	for (int i = 0; i < max_n; i++){
		printf("%d ", q->data[i + 1]);
	}
	printf("\n");
	for (int i = 0; i < max_n; i++){
		//pop(q);
		//printf("%d ", q->data[q->cnt]);
		printf("index %d : %d ", i, top(q));
		pop(q);
	}
#undef max_n
	clear(q);
}

线性建堆

//线性建堆
#include <stdio.h>
#include <stdlib.h>

#define swap(a, b) __typeof(a) t = a; a = b; b = t

void downUpdate(int *arr, int n, int ind){
	//arr -= 1;//数组下标从1开始
	//从第ind层开始向下调整
	//儿子存在
	while((ind << 1) <= n){
		int temp = ind, l = ind << 1, r = ind << 1 | 1;
		if(arr[temp] < arr[l]) temp = l;
		if (r <= n && arr[temp] < arr[r]) temp = r;
		if (temp == ind) break;
		swap(arr[temp], arr[ind]);
		ind = temp;//调整的那棵树
	}
	return;
}

void heap_sort(int *arr, int n){
	//建堆
	arr -= 1;//arr[1]为首元素
	for(int i = n >> 1; i >= 1; i--){//从倒数第2排开始，对所有元素调整
		//自下而上调整
		downUpdate(arr, n, i);//元素个数，序号为i的元素
	}

	//用堆排序
	for (int i = n; i > 1; i--){//调整n - 1次
		//堆顶与堆尾交换，然后自上而下调整
		//相当于进行n-1次pop操作
		swap(arr[i], arr[1]);//第一个元素已经排好了
		downUpdate(arr, i - 1, 1);//少一个元素，从第1个元素调整
	}
	return;
}

int main(){
	int arr[6] = {3, 1, 4, 6, 3, 2};
	heap_sort(arr, 6);
	for (int i = 0; i < 6; i++){
		printf("%d ", arr[i]);
	}
}