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;
}