堆的C实现

heap.h

#ifndef _HEAP_H
#define _HEAP_H

typedef struct{
	int *ptData;
	int maxSize;
	int size;
}T_Heap;
#endif

heap.cpp

#include "heap.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "stdbool.h"

void swap(int *a, int *b)
{
	if (NULL == a || NULL == b)
	{
		return;
	}

	int temp = *a;
	*a = *b;
	*b = temp;
}

bool HeapInit(T_Heap *ptHeap, int size)
{
	bool bInitSuccess = false;

	if (NULL == ptHeap || size <= 0)
	{
		return bInitSuccess;
	}
	ptHeap->maxSize = size;
	ptHeap->size = 0;
	ptHeap->ptData = (int *)malloc(sizeof(int) * (size + 1));
	if (NULL == ptHeap->ptData)
	{
		return bInitSuccess;
	}
	memset(ptHeap->ptData, 0, sizeof(int) * size);
	return true;
}

void HeapShiftUp(T_Heap *ptHeap, int i)
{
	if (NULL == ptHeap || i <= 0)
	{
		return;
	}
	bool flag = true;
	while (flag && 1 != i)
	{
		if (ptHeap->ptData[i] > ptHeap->ptData[i / 2])
		{
			swap(&(ptHeap->ptData[i]), &(ptHeap->ptData[i / 2]));
		}
		else
		{
			flag = false;
		}

		i /= 2;
	}
}

void HeapShiftDown(T_Heap *ptHeap, int count, int i)
{
	if (NULL == ptHeap || count <= 0 || i <= 0)
	{
		return;
	}
	bool flag = true;
	while (flag && (i *= 2) <= count)
	{
		if (i + 1 <= count && ptHeap->ptData[i+1] > ptHeap->ptData[i])
		{
			i++;
		}
		if (ptHeap->ptData[i] > ptHeap->ptData[i / 2] )
		{
			swap(&(ptHeap->ptData[i]), &(ptHeap->ptData[i / 2]));
		}
		else
		{
			flag = false;
		}
	}
}

void HeapInsert(T_Heap *ptHeap, int val)
{
	if (NULL == ptHeap)
	{
		return;
	}
	++(ptHeap->size);
	ptHeap->ptData[ptHeap->size] = val;
	HeapShiftUp(ptHeap, ptHeap->size);
}

void HeapCreate(T_Heap *ptHeap, int a[], int len)
{
	if (NULL == a || len <= 0)
	{
		return;
	}
	for (int i = 0; i < len; i++)
	{
		HeapInsert(ptHeap, a[i]);
	}
}

void HeapDelete(T_Heap *ptHeap, int i)
{
	int a = 0;
	int b = 0;
	if (NULL == ptHeap || i > ptHeap->size)
	{
		return;
	}
	else
	{
		a = ptHeap->ptData[i];
		b = ptHeap->ptData[ptHeap->size];
		ptHeap->ptData[i] = b;
		--(ptHeap->size);
		if (a > b)
		{
			HeapShiftDown(ptHeap, ptHeap->size, i);
		}
		else
		{
			HeapShiftUp(ptHeap, i);
		}
	}
}

void HeapPop(T_Heap *ptHeap)
{
	if (NULL == ptHeap)
	{
		return;
	}
	HeapDelete(ptHeap, 1);
}

void HeapSort(T_Heap *ptHeap)
{
	if (NULL == ptHeap)
	{
		return;
	}
	for (int i = ptHeap->size; i > 0; i--)
	{
		swap(&(ptHeap->ptData[1]), &(ptHeap->ptData[i]));
		HeapShiftDown(ptHeap, i - 1, 1);
	}
}

void HeapShow(T_Heap *ptHeap)
{
	if (NULL == ptHeap)
	{
		return;
	}
	for (int i = 1; i <= ptHeap->size; i++)
	{
		printf("%d ", ptHeap->ptData[i]);
	}
	printf("\n");
}