C语言实现小堆

二叉树知识点

二叉树第k层结点数的最大值为。

满二叉树：每一层结点都达到最大值的二叉树称为满二叉树。

完全二叉树：最后一层可能满可能不满，其他层都是满的二叉树称为完全二叉树。满二叉树是特殊的完美二叉树。

任何二叉树，若度为0的结点为n0,度为2 的结点为n2，则有n2=n0-1; 

在二叉树中已知父节点的下标为parent，则左孩子的下标为leftchild=parent*2+1，右孩子的下标为rightchild=parent*2+2；

在二叉树中已知左孩子或右孩子的下标为child，则父节点的下标为（child-1）/2；

关于复杂度的计算

小堆的实现

Heap.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct Heap Heap;
typedef  int HPDataType;
struct Heap {
	HPDataType* a;
	int size;
	int capacity;
};
void AdjustDown(HPDataType* a, int n, int root);
void HeapInite(Heap* php, HPDataType* a, int n);
void HeapPrint(Heap* php);
void HeapSort(HPDataType* a,int size);
void HeapPush(Heap* php, HPDataType val);
void AdjustUp(HPDataType* a, int child);
void HeapPop(Heap* php);
int HeapEmpty(Heap* php);
HPDataType HeapTop(Heap* php);
void HeapDestory(Heap* php);

Heap.c

#include "Heap.h"
void Swap(HPDataType* a, HPDataType* b) {
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}
void AdjustDown(HPDataType* a, int n, int root) {
	//建立小堆
	//向下调整要求左右子树都是小堆
	int parent = root;
	int child = parent* 2 + 1;
	while (child < n) {
		if (child + 1 < n && a[child + 1] < a[child]) {
			child += 1;
		}
		if (a[parent] > a[child]) {
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			break;
		}
	}

}
void HeapInite(Heap* php, HPDataType* a, int n) {
	assert(a);
	HPDataType* p = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (p == NULL) {
		printf("fail\n");
		exit(-1);
	}
	php->a = p;
	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->size = n;
	php->capacity = n;
	for (int i = ((n - 1) - 1) / 2; i >= 0; i--) {
		AdjustDown(php->a, n,i);
	}
}
void HeapPrint(Heap* php) {
	for (int i = 0; i < php->size; i++) {
		printf("%d ", php->a[i]);
	}
	printf("\n");
}
void HeapSort(HPDataType* a, int size) {
	//最后一个数据的下标为size-1，子节点下标是i,父节点下标是(i-1)/2;
	for (int i = ((size - 1)-1) / 2; i >= 0; i--) {
		AdjustDown(a, size,i);
	}
	int end = size-1;
	while (end > 0) {
		Swap(&a[end], &a[0]);
		end -= 1;
		AdjustDown(a, end+1, 0);
	}
}
void HeapPush(Heap* php, HPDataType val) {
	if (php->size == php->capacity) {
		if (php->capacity == 0) {
			php->capacity = 4;
		}else{
			php->capacity *= 2;
		}
		HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * (php->capacity));
		if (tmp == NULL) {
			printf("fail");
			exit(-1);
		}
		php->a = tmp;
	}
	php->a[php->size] = val;
	php->size++;
	AdjustUp(php->a, php->size-1);
}
void AdjustUp(HPDataType* a, int child) {
	int parent = (child-1)/2;
	while (child > 0) {
		if (a[parent] > a[child]) {
			Swap(&a[parent], &a[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}
HPDataType HeapTop(Heap* php) {
	assert(!HeapEmpty(php));
	return php->a[0];
}
void HeapPop(Heap* php) {
	assert(!HeapEmpty(php));
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size -= 1;
	AdjustDown(php->a, php->size, 0);
}
int HeapEmpty(Heap* php) {
	return php->size == 0;
}
void HeapDestory(Heap* php) {
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}