HeapSort——堆排序实现（算法类）

<heapsort.h>

#ifndef _HEAP_SORT_H_
#define _HEAP_SORT_H_

#define INC_HEAP_SIZE 10

typedef int* Heap_Data;

typedef struct _HeapElem{
long key;
Heap_Data data;
} HeapElem;

typedef struct _Heap{
int length;
int max_size;
int heap_size;
HeapElem *pElem;
} Heap;

#define HEAP_ELEM_SIZE sizeof(HeapElem)

#define ELEM(heap, i) ((HeapElem *) (heap->pElem + HEAP_ELEM_SIZE * i))
#define ELEM_KEY(heap, i) (((HeapElem *) (heap->pElem + HEAP_ELEM_SIZE * i))->key)

#define PARENT(i) ((i+1)/2-1)
#define LEFT(i) (2*(i+1)-1)
#define RIGHT(i) (2*(i+1))

#define EXCHANGE(heap, i, j) {\
HeapElem tmp= *((HeapElem *) (heap->pElem + HEAP_ELEM_SIZE * (i)));\
*((HeapElem *) (heap->pElem + HEAP_ELEM_SIZE * (i))) = *((HeapElem *) (heap->pElem + HEAP_ELEM_SIZE * (j)));\
*((HeapElem *) (heap->pElem + HEAP_ELEM_SIZE * (j))) = tmp;\
}

void init_heap(Heap* heap);
void insert_heap(Heap* heap, const HeapElem* elem);
void max_heap(Heap* heap, int i);
void destroy_heap(Heap* heap);
void print_heap(const Heap* heap);
HeapElem* create_elem(Heap_Data data, long key);
void build_max_heap(Heap* heap);
void heap_sort(Heap* heap);
void create_elem1(HeapElem** elem, Heap_Data data, long key);

#endif

<heapsort.c>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include "heapsort.h"

void init_heap(Heap* heap)
{
memset(heap, 0, sizeof(Heap));
}

void insert_heap(Heap* heap, const HeapElem* elem)
{
HeapElem *pNewElem = NULL;
if(heap->length == heap->max_size)
{

if((pNewElem = (HeapElem *) malloc((heap->max_size + INC_HEAP_SIZE)* HEAP_ELEM_SIZE))
!= NULL)
{
memset(pNewElem, 0,(heap->max_size + INC_HEAP_SIZE)* HEAP_ELEM_SIZE);
memcpy(pNewElem, heap->pElem, heap->length * HEAP_ELEM_SIZE);
free(heap->pElem);
heap->pElem = pNewElem;
heap->max_size += INC_HEAP_SIZE;
}else
{
printf("err 1");
exit(-1);
}
}
memcpy(heap->pElem + heap->length * HEAP_ELEM_SIZE, elem, HEAP_ELEM_SIZE);
heap->length++;
heap->heap_size++;
}

void destroy_heap(Heap* heap)
{
if(heap->length != 0)
{
free(heap->pElem);
memset(heap, 0, sizeof(Heap));
}
}

void print_heap(const Heap* heap)
{
int i = 0;

printf("The heap size is:%d\n", heap->heap_size);
printf("The heap max_size is: %d\n", heap->max_size);
printf("the heap key elements are:\n");
for(i = 0; i < heap->length; i++)
{
printf(" %d ", ((HeapElem *)(heap->pElem + HEAP_ELEM_SIZE*i))->key);
}
printf("\n\n");
}

void max_heap(Heap* heap, int i)
{
int largest = i;

if(i<0 || i > (heap->heap_size/2 -1))
return;

if(LEFT(i) < heap->heap_size && ELEM_KEY(heap,LEFT(i))>=ELEM_KEY(heap, i))
{
largest = LEFT(i);
}
if(RIGHT(i) < heap->heap_size
&& ELEM_KEY(heap,RIGHT(i)) >= ELEM_KEY(heap, largest))
{
largest = RIGHT(i);
}

if(i!=largest)
{
EXCHANGE(heap, i, largest);
max_heap(heap, largest);
}

}

HeapElem* create_elem(Heap_Data data, long key)
{
HeapElem *elem = NULL;
if(NULL == (elem = (HeapElem *)malloc(HEAP_ELEM_SIZE)))
{
exit(-1);
}
elem->data = data;
elem->key = key;
return elem;
}

void create_elem1(HeapElem** elem, Heap_Data data, long key)
{
if(NULL == (*elem = (HeapElem *)malloc(HEAP_ELEM_SIZE)))
{
exit(-1);
}
(*elem)->data = data;
(*elem)->key = key;
}

void build_max_heap(Heap* heap)
{
int i = 0;

if(NULL==heap || 0==heap->heap_size)
return;
for (i = heap->heap_size/2 - 1; i>=0; i--)
{
max_heap(heap, i);
}
}

void heap_sort(Heap* heap)
{
int i = 0;

build_max_heap(heap);
print_heap(heap);
for(i = heap->heap_size - 1; i > 0; i--)
{
heap->heap_size--;
EXCHANGE(heap, 0, heap->heap_size);
max_heap(heap, 0);
print_heap(heap);
}
}

<main.c>
#include <stdio.h>
#include <stdlib.h>

#include "heapsort.h"

int main(char args[]){
Heap *heap = NULL;
HeapElem* elem = NULL;

heap = (Heap *)malloc(sizeof(Heap));
init_heap(heap);

insert_heap(heap, create_elem(NULL, 2));
insert_heap(heap, create_elem(NULL, 5));
insert_heap(heap, create_elem(NULL, 8));
insert_heap(heap, create_elem(NULL, 7));
insert_heap(heap, create_elem(NULL, 15));
insert_heap(heap, create_elem(NULL, 3));
insert_heap(heap, create_elem(NULL, 3));
insert_heap(heap, create_elem(NULL, 11));

print_heap(heap);

heap_sort(heap);
print_heap(heap);
getchar();
return 0;
}