Heap fixes

Author: chrisguiney

include/heap_t.h

@@ -12,13 +12,17 @@
 
 typedef struct {
 	comparator	cmp;		// Comparator function
-	int		size;		// Max size
-	int		items;		// Items currently in heap
+	int			size;		// Max size
+	int			items;		// Items currently in heap
+	dtor		destructor;	// Function to free items
 	size_t		item_size;	// Size of item
 	void**		list;		// Array of items
 } heap_t;
 
-heap_t* heap_create(int size, size_t type_size, comparator cmp);
+heap_t* heap_create(int size,
+					size_t type_size,
+					comparator cmp,
+					dtor destructor);
 void heap_clear(heap_t* heap);
 void heap_destroy(heap_t* heap);
 void heap_push(heap_t* heap, void* item);

src/heap_t.c

@@ -29,7 +29,7 @@ void heap_swap(heap_t* heap, int a, int b)
 /*
  * Create a new fixed size heap.
  */
-heap_t* heap_create(int size, size_t type_size, comparator cmp)
+heap_t* heap_create(int size, size_t type_size, comparator cmp, dtor destructor)
 {
 	heap_t* h = NULL;
 
@@ -43,6 +43,7 @@ heap_t* heap_create(int size, size_t type_size, comparator cmp)
 	h->items = 0;
 	h->size = size;
 	h->item_size = type_size;
+	h->destructor = destructor;
 	h->list = calloc(1, type_size * size);
 
 	check_mem(h->list);
@@ -61,37 +62,43 @@ heap_t* heap_create(int size, size_t type_size, comparator cmp)
 /*
  * Decallocate every item in the heap.
  */
-void heap_clear(heap_t* heap)
+void heap_clear(heap_t* h)
 {
 	int i = 0;
-	if(heap->items > 0) {
-		for(i = 0; i < heap->size; i++) {
-			if(heap->list[i] != NULL) {
-				free(heap->list[i]);
+	if(h->items <= 0) {
+		return;
+	}
+	for(i = 0; i < h->size; i++) {
+		if(h->list[i] != NULL) {
+			if(h->destructor != NULL) {
+				h->destructor(h->list[i]);
 			}
+			h->list[i] = NULL;
 		}
 	}
 }
 
 /*
  * Deallocate a heap
  */
-void heap_destroy(heap_t* heap)
+void heap_destroy(heap_t* h)
 {
-	if(heap != NULL) {
-		if(heap->list != NULL) {
-			free(heap->list);
-		}
-		free(heap);
+	if(h == NULL) {
+		return;
+	}
+	if(h->list != NULL) {
+		heap_clear(h);
+		free(h->list);
 	}
+	free(h);
 }
 
 /*
  * Return the index of the items parent
  */
-int heap_parent(const heap_t* heap, const int pos) {
+int heap_parent(const heap_t* h, const int pos) {
 	check(pos >= 0, "Heap position must be greater than 0");
-	check(pos < heap->items, "Heap position is out of range");
+	check(pos < h->items, "Heap position is out of range");
 	return (pos - 1) / 2;
 
 error:
@@ -101,15 +108,15 @@ int heap_parent(const heap_t* heap, const int pos) {
 /*
  * Determine if the element at pos is a leaf node
  */
-bool heap_leaf(heap_t* heap, int pos) {
-	return (pos >= heap->items / 2) && (pos < heap->items);
+bool heap_leaf(heap_t* h, int pos) {
+	return (pos >= h->items / 2) && (pos < h->items);
 }
 
 /*
  * Get the index of the left child of element at pos
  */
-int heap_left(heap_t* heap, int pos) {
-	check(pos < heap->items, "Heap position is out of range");
+int heap_left(heap_t* h, int pos) {
+	check(pos < h->items, "Heap position is out of range");
 	return (2 * pos) + 1;
 
 error:
@@ -119,8 +126,8 @@ int heap_left(heap_t* heap, int pos) {
 /*
  * Get index of the right child of element at pos
  */
-int heap_right(heap_t* heap, int pos) {
-	check(pos < heap->items, "Heap position is out of range");
+int heap_right(heap_t* h, int pos) {
+	check(pos < h->items, "Heap position is out of range");
 	return (2 * pos) + 2;
 
 error:
@@ -130,21 +137,21 @@ int heap_right(heap_t* heap, int pos) {
 /*
  * Move element at pos to its correct position within the heap
  */
-void heap_sift(heap_t* heap, int pos) {
+void heap_sift(heap_t* h, int pos) {
 	int j;
-	while(!heap_leaf(heap, pos)) {
-		j = heap_left(heap, pos);
+	while(!heap_leaf(h, pos)) {
+		j = heap_left(h, pos);
 
-		if((j < heap->items - 1) &&
-		   (heap->cmp(heap->list[j], heap->list[j+1]) > 0)) {
+		if((j < h->items - 1) &&
+		   (h->cmp(h->list[j], h->list[j+1]) > 0)) {
 			j++;
 		}
 
-		if(heap->cmp(heap->list[pos], heap->list[j]) <= 0) {
+		if(h->cmp(h->list[pos], h->list[j]) <= 0) {
 			return;
 		}
 
-		heap_swap(heap, pos, j);
+		heap_swap(h, pos, j);
 		pos = j;
 	}
 }

tests/heap_t_tests.c

@@ -7,15 +7,14 @@ int int_cmp_asc(void* a, void* b) {
 }
 
 char* test_create() {
-	heap_t* heap = heap_create(10, sizeof(int), int_cmp_asc);
+	heap_t* heap = heap_create(10, sizeof(int), int_cmp_asc, NULL);
 	mu_assert(heap != NULL, "Failed to create heap");
-	heap_clear(heap);
 	heap_destroy(heap);
 	return NULL;
 }
 
 char* test_heap_push() {
-	heap_t* heap = heap_create(10, sizeof(int), int_cmp_asc);
+	heap_t* heap = heap_create(10, sizeof(int), int_cmp_asc, NULL);
 	mu_assert(heap != NULL, "Failed to create heap");
 
     heap_push(heap, (void*) 5);
@@ -38,7 +37,7 @@ char* test_heap_push() {
 }
 
 char* test_heap_pushpop() {
-	heap_t* heap = heap_create(10, sizeof(int), int_cmp_asc);
+	heap_t* heap = heap_create(10, sizeof(int), int_cmp_asc, NULL);
 	debug("Pushpop 4: %d", (int) heap_pushpop(heap, (void*) 4));
     heap_push(heap, (void*) 1);
     heap_push(heap, (void*) 2);
@@ -57,6 +56,7 @@ char* test_heap_pushpop() {
     	n = (int) heap_pop(heap);
     	mu_assert(n == i, "Incorrect value popped off the heap");
     }
+    heap_destroy(heap);
     return NULL;
 }