14 files changed, 56 insertions, 58 deletions

diff --git a/src/allocator.c b/src/allocator.c
index 98fa69f..d6aeea9 100644
--- a/src/allocator.c
+++ b/src/allocator.c
@@ -49,7 +49,7 @@ char *
 allocator_strdup(struct allocator *allocator, const char *str)
 {
         size_t n;
-        char * dest;
+        char  *dest;
 
         n    = strlen(str) + 1;
         dest = allocator_malloc(allocator, n);
@@ -74,6 +74,7 @@ allocator_malloc_zero(struct allocator *allocator, size_t n)
 }
 
 int
-main()
+main(void)
 {
+        return 0;
 }
diff --git a/src/arraylist.c b/src/arraylist.c
index 0db35ad..7a62fd4 100644
--- a/src/arraylist.c
+++ b/src/arraylist.c
@@ -11,7 +11,7 @@
 typedef int T;
 
 struct ArrayList {
-        T **   array;
+        T    **array;
         size_t size;
         size_t capacity;
 };
@@ -83,7 +83,7 @@ ArrayList_growIfNeeded(struct ArrayList *arrayList)
                 }
                 else {
                         size_t new_capacity  = arrayList->capacity * 3 / 2; // *= 1.5
-                        T **   new_arrayList = ArrayList_allocateArray(arrayList->array, new_capacity);
+                        T    **new_arrayList = ArrayList_allocateArray(arrayList->array, new_capacity);
 
                         arrayList->capacity = new_capacity;
                         arrayList->array    = new_arrayList;
@@ -225,7 +225,7 @@ static int
 ArrayList_bsearchHelper(const void *ctx, const void *el)
 {
         const struct bsearchHelper_context *context = ctx;
-        const const_T_ptr *                 element = el;
+        const const_T_ptr                  *element = el;
 
         return context->cmp(context->key, *element, context->args);
 }
@@ -245,7 +245,7 @@ ArrayList_binarySearch(struct ArrayList *arrayList, void *key, int cmp(void *, c
 
         T **pos = bsearch(&context, arrayList->array, arrayList->size, sizeof arrayList->array[0], ArrayList_bsearchHelper);
         if ( pos ) {
-                *loc = (size_t)(pos - arrayList->array);
+                *loc = (size_t) (pos - arrayList->array);
                 return true;
         }
         else {
diff --git a/src/binary-search-tree.c b/src/binary-search-tree.c
index 93690e2..780ba70 100644
--- a/src/binary-search-tree.c
+++ b/src/binary-search-tree.c
@@ -318,7 +318,7 @@ tree_apply_postorder(struct tree_node *tree, void (*visit)(T key, void *cl), voi
 /* --8<-- tree_stack_type */
 struct stack_item {
         struct stack_item *next;
-        struct tree_node * data;
+        struct tree_node  *data;
 };
 
 struct stack {
@@ -404,7 +404,7 @@ stack_free(struct stack *stack)
 /* --8<-- tree_queue_type */
 struct queue_item {
         struct queue_item *next;
-        struct tree_node * data;
+        struct tree_node  *data;
 };
 
 struct queue {
@@ -792,7 +792,7 @@ main(void)
         show_tree(tree, 0, 0);
 
         struct tree_iterator it;
-        struct tree_node *   node = tree_preorder_iterator_first(&it, tree);
+        struct tree_node    *node = tree_preorder_iterator_first(&it, tree);
         while ( node ) {
                 fprintf(stdout, "%d\n", node->key);
 
diff --git a/src/deque.c b/src/deque.c
index 4efce63..947c404 100644
--- a/src/deque.c
+++ b/src/deque.c
@@ -102,7 +102,7 @@ grow_map(struct deque *d)
         assert(d);
 
         const size_t capacity = d->map_capacity + d->map_capacity / 2;
-        T **         map      = allocate(capacity, sizeof *map);
+        T          **map      = allocate(capacity, sizeof *map);
 
         // copy elements
         size_t i, j;
diff --git a/src/double-linked-list.c b/src/double-linked-list.c
index 55e42d7..1e573c0 100644
--- a/src/double-linked-list.c
+++ b/src/double-linked-list.c
@@ -450,7 +450,7 @@ merge_test(void)
 }
 
 void
-ls()
+ls(void)
 {
         struct dlist list;
 
@@ -459,15 +459,15 @@ ls()
         for ( int i = 0; i != 30000000; ++i )
                 dlist_insert_prev(&list, list.tail, rand() % 9999);
 
-        //print_list("Unsortiert:", &list);
+        // print_list("Unsortiert:", &list);
         printf("start\n");
         clock_t start = clock();
         dlist_sort(&list);
         clock_t ende = clock();
 
         printf("Dauer: %.3fsec\n", ((double) ende - start) / CLOCKS_PER_SEC);
-        //print_list("Sortiert:", &list);
-        //print_list_rev("Sortiert:", &list);
+        // print_list("Sortiert:", &list);
+        // print_list_rev("Sortiert:", &list);
 
         dlist_free(&list);
 }
diff --git a/src/hash-table.c b/src/hash-table.c
index 256fac9..8c93bc6 100644
--- a/src/hash-table.c
+++ b/src/hash-table.c
@@ -11,7 +11,7 @@ typedef int T;
 
 struct hash_item {
         struct hash_item *next;
-        char *            key;
+        char             *key;
         T                 data;
 };
 
@@ -48,7 +48,7 @@ static struct hash_item *
 hash_add(struct hash_item *next, const char *key, T data)
 {
         struct hash_item *new_item;
-        char *            new_key;
+        char             *new_key;
 
         new_key  = strdup(key); // strdup: not standard but commonly used...
         new_item = malloc(sizeof *new_item);
@@ -199,7 +199,7 @@ print(const char *key, T data, void *cl)
 }
 
 int
-main()
+main(void)
 {
         struct hash_tab ht[1];
         char            word[100];
diff --git a/src/heap.c b/src/heap.c
index 091e761..45902a4 100644
--- a/src/heap.c
+++ b/src/heap.c
@@ -277,11 +277,11 @@ main(void)
         // Kapitel 5.10, Seite 372 ff.
         T heap[20] = { 18, 18, 16, 9, 7, 1, 9, 3, 7, 5 };
 
-        //heapify(heap, 10);
+        // heapify(heap, 10);
         assert(is_heap(heap, 10));
         print_heap(heap, 10);
 
-        //heap[10] = 13; fixup(heap, 10);
+        // heap[10] = 13; fixup(heap, 10);
         swap(heap, 0, 9);
         fixdown(heap, 0, 9);
 
diff --git a/src/quicksort.c b/src/quicksort.c
index 4657dcd..0b20ab9 100644
--- a/src/quicksort.c
+++ b/src/quicksort.c
@@ -3,8 +3,6 @@
 #include <stdlib.h>
 #include <time.h>
 
-#include "util.h"
-
 static int
 bigrand(void)
 {
@@ -124,7 +122,7 @@ quickSort(int arr[], int low, int high)
 {
         while ( low < high ) {
                 /* pi is partitioning index, arr[p] is now
-           at right place */
+                   at right place */
                 int pi = partition(arr, low, high);
 
                 if ( pi - low < high - pi ) {
@@ -299,6 +297,7 @@ heapsort_bu(T *data, int n) // zu sortierendes Feld und seine Länge
 
                 data[child] = val; // versickerten Wert eintragen
         }
+        printf("%d\n", count);
 }
 
 /*----------------------------------------------------------------------*/
@@ -356,7 +355,7 @@ bottom_up_heapsort(T r[], int n)
 {
         int k;
         T   x;
-        T * v;
+        T  *v;
 
         v = r - 1; /* The address shift */
 
@@ -606,7 +605,7 @@ test_sorting(T a[], int n)
 void
 do_one_test(int n, void (*do_sort)(T a[], int n), void (*gen_testset)(T a[], int n))
 {
-        T *     a;
+        T      *a;
         clock_t start, ende;
 
         a = malloc(sizeof(T) * (size_t) n);
@@ -649,10 +648,10 @@ main(void)
         do_all_tests("heapsort_bu", n, heapsort_bu);
         do_all_tests("bottom_up_heapsort", n, bottom_up_heapsort);
         do_all_tests("c_quicksort", n, c_quicksort);
-        //do_all_tests("g4g_quicksort", n, g4g_quicksort);
-        //do_all_tests("sed_quicksort", n, sed_quicksort);
+        // do_all_tests("g4g_quicksort", n, g4g_quicksort);
+        // do_all_tests("sed_quicksort", n, sed_quicksort);
         do_all_tests("my_introsort", n, my_introsort);
-        //do_all_tests("my_quicksort", n, my_quicksort);
+        // do_all_tests("my_quicksort", n, my_quicksort);
         do_all_tests("pp_quicksort", n, pp_quicksort);
         do_all_tests("pp_quicksort_it", n, pp_quicksort_it);
 
diff --git a/src/red-black-tree.c b/src/red-black-tree.c
index 7c2d2c1..5ae0f31 100644
--- a/src/red-black-tree.c
+++ b/src/red-black-tree.c
@@ -6,8 +6,6 @@
 #include <stdlib.h>
 #include <time.h>
 
-#include "util.h"
-
 /* The authors of this work have released all rights to it and placed it
 in the public domain under the Creative Commons CC0 1.0 waiver
 (http://creativecommons.org/publicdomain/zero/1.0/).
@@ -27,22 +25,22 @@ enum rbtree_node_color { RED,
                              BLACK };
 
 typedef struct rbtree_node_t {
-        void *                 key;
-        void *                 value;
-        struct rbtree_node_t * left;
-        struct rbtree_node_t * right;
-        struct rbtree_node_t * parent;
+        void                  *key;
+        void                  *value;
+        struct rbtree_node_t  *left;
+        struct rbtree_node_t  *right;
+        struct rbtree_node_t  *parent;
         enum rbtree_node_color color;
-} * rbtree_node;
+} *rbtree_node;
 
 typedef struct rbtree_t {
         rbtree_node root;
-} * rbtree;
+} *rbtree;
 
 typedef int (*compare_func)(void *left, void *right);
 
-rbtree rbtree_create();
-void * rbtree_lookup(rbtree t, void *key, compare_func compare);
+rbtree rbtree_create(void);
+void  *rbtree_lookup(rbtree t, void *key, compare_func compare);
 void   rbtree_insert(rbtree t, void *key, void *value, compare_func compare);
 void   rbtree_delete(rbtree t, void *key, compare_func compare);
 
@@ -187,7 +185,7 @@ verify_property_5_helper(node n, int black_count, int *path_black_count)
 }
 
 rbtree
-rbtree_create()
+rbtree_create(void)
 {
         rbtree t = malloc(sizeof *t);
         t->root  = NULL;
@@ -538,8 +536,8 @@ static void print_tree_helper(rbtree_node n, int indent);
 int
 compare_int(void *leftp, void *rightp)
 {
-        int left  = (int) leftp;
-        int right = (int) rightp;
+        long left  = (long) leftp;
+        long right = (long) rightp;
         if ( left < right )
                 return -1;
         else if ( left > right )
@@ -575,16 +573,16 @@ print_tree_helper(rbtree_node n, int indent)
         for ( i = 0; i < indent; i++ )
                 fputs(" ", stdout);
         if ( n->color == BLACK )
-                printf("%d\n", (int) n->key);
+                printf("%ld\n", (long) n->key);
         else
-                printf("<%d>\n", (int) n->key);
+                printf("<%ld>\n", (long) n->key);
         if ( n->left != NULL ) {
                 print_tree_helper(n->left, indent + INDENT_STEP);
         }
 }
 
 int
-main()
+main(void)
 {
         int    i;
         rbtree t = rbtree_create();
diff --git a/src/shellsort.c b/src/shellsort.c
index 29e6bf8..d35e5b0 100644
--- a/src/shellsort.c
+++ b/src/shellsort.c
@@ -9,10 +9,10 @@ typedef int T;
 void
 shellsort(T a[], size_t n)
 {
-        //static const size_t gaps[] = { 701, 301, 132, 57, 23, 10, 4, 1 };
+        // static const size_t gaps[] = { 701, 301, 132, 57, 23, 10, 4, 1 };
 
         // Wikipedia:
-        //static const size_t gaps[] = { 2147483647, 1131376761, 410151271, 157840433, 58548857, 21521774, 8810089, 3501671, 1355339, 543749, 213331, 84801, 27901, 11969, 4711, 1968, 815, 271, 111, 41, 13, 4, 1 };
+        // static const size_t gaps[] = { 2147483647, 1131376761, 410151271, 157840433, 58548857, 21521774, 8810089, 3501671, 1355339, 543749, 213331, 84801, 27901, 11969, 4711, 1968, 815, 271, 111, 41, 13, 4, 1 };
 
         // https://www.cs.princeton.edu/~rs/shell/paperF.pdf
         static const size_t gaps[] = { 1391376, 463792, 198768, 86961, 33936, 13776, 4592, 1968, 861, 336, 112, 48, 21, 7, 3, 1 };
diff --git a/src/single-linked-list.c b/src/single-linked-list.c
index d18dae4..ab37dc2 100644
--- a/src/single-linked-list.c
+++ b/src/single-linked-list.c
@@ -218,7 +218,7 @@ print_data(T data, void *cl)
 /* -->8-- */
 
 int
-main()
+main(void)
 {
         clock_t start;
 
@@ -255,7 +255,7 @@ main()
         x     = list_sort(x);
         printf("Fertig: %.3lf sec\n", (double) (clock() - start) / CLOCKS_PER_SEC);
 
-        //list_apply(x, print_data);
+        // list_apply(x, print_data);
         printf("Len: %zu\n", list_length(x));
 
         list_free(x);
diff --git a/src/stack-array.c b/src/stack-array.c
index a36de7b..ca68a03 100644
--- a/src/stack-array.c
+++ b/src/stack-array.c
@@ -9,7 +9,7 @@
 typedef int T;
 
 struct stack {
-        T *    array;
+        T     *array;
         size_t sz, p;
 };
 /* -->8-- */
@@ -150,7 +150,7 @@ test_stack(void)
 }
 
 int
-main()
+main(void)
 {
         test_stack();
         return EXIT_SUCCESS;
diff --git a/src/stack-linked-list.c b/src/stack-linked-list.c
index 48b9eba..7c01a1d 100644
--- a/src/stack-linked-list.c
+++ b/src/stack-linked-list.c
@@ -85,7 +85,7 @@ stack_free(struct stack *stack)
 /* -->8-- */
 
 int
-main()
+main(void)
 {
         struct stack stack[1];
 
@@ -96,11 +96,11 @@ main()
 
         /*
         while ( !stack_empty(stack) ) {
-                int i;
-                if ( stack_pop(stack, &i) )
-                        printf("%d\n", i);
-                else
-                        ERROR("this shouldn't happen!");
+            int i;
+            if ( stack_pop(stack, &i) )
+                printf("%d\n", i);
+            else
+                ERROR("this shouldn't happen!");
         }
         */
 
diff --git a/src/treeutil.h b/src/treeutil.h
index 76627c0..a68ff35 100644
--- a/src/treeutil.h
+++ b/src/treeutil.h
@@ -1,7 +1,7 @@
 // aux display and verification routines, helpful but not essential
 struct trunk {
         struct trunk *prev;
-        const char *  str;
+        const char   *str;
 };
 
 static void
@@ -21,7 +21,7 @@ show_tree(struct tree_node *root, struct trunk *prev, int is_left)
                 return;
 
         struct trunk this_disp = { prev, "    " };
-        const char * prev_str  = this_disp.str;
+        const char  *prev_str  = this_disp.str;
         show_tree(root->right, &this_disp, 1);
 
         if ( !prev )