3 files changed, 50 insertions, 40 deletions

diff --git a/hashtab.c b/hashtab.c
index 6b35c89..e53da51 100644
--- a/hashtab.c
+++ b/hashtab.c
@@ -1,8 +1,8 @@
+#include <ctype.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdbool.h>
-#include <ctype.h>
 
 #include "util.h"
 
@@ -10,19 +10,19 @@ typedef int T;
 
 struct hash_item {
         struct hash_item *next;
-        char *key;
-        T data;
+        char *            key;
+        T                 data;
 };
 
 struct hash_tab {
-        struct hash_item *table[251];           // fit for your needs...
+        struct hash_item *table[251]; // fit for your needs...
 };
 
 static unsigned long
 hash_key(const unsigned char *str)
 {
         unsigned long hash = 5381;
-        int c;
+        int           c;
 
         while ( (c = *str++) != '\0' )
                 hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
@@ -41,9 +41,9 @@ 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_key  = strdup(key); // strdup: not standard but commonly used...
         new_item = malloc(sizeof(*new_item));
 
         if ( new_key == NULL || new_item == NULL ) {
@@ -54,7 +54,7 @@ hash_add(struct hash_item *next, const char *key, T data)
         }
 
         new_item->next = next;
-        new_item->key = new_key;
+        new_item->key  = new_key;
         new_item->data = data;
 
         return new_item;
@@ -63,9 +63,9 @@ hash_add(struct hash_item *next, const char *key, T data)
 T *
 hash_lookup(struct hash_tab *ht, const char *key, T data, int create)
 {
-        unsigned long h;
+        unsigned long     h;
         struct hash_item *item;
-   
+
         h = hash_key((const unsigned char *) key) % NELEM(ht->table);
         for ( item = ht->table[h]; item; item = item->next )
                 if ( strcmp(key, item->key) == 0 )
@@ -86,10 +86,10 @@ hash_lookup(struct hash_tab *ht, const char *key, T data, int create)
 bool
 hash_delete(struct hash_tab *ht, const char *key)
 {
-        unsigned long h;
+        unsigned long     h;
         struct hash_item *prev, *p;
 
-        h = hash_key((const unsigned char *) key) % NELEM(ht->table);
+        h    = hash_key((const unsigned char *) key) % NELEM(ht->table);
         prev = NULL;
         for ( p = ht->table[h]; p; p = p->next ) {
                 if ( strcmp(key, p->key) == 0 ) {
@@ -101,7 +101,7 @@ hash_delete(struct hash_tab *ht, const char *key)
                         free(p->key);
                         free(p);
 
-                        return true;            // successfully removed!
+                        return true; // successfully removed!
                 }
                 prev = p;
         }
@@ -134,27 +134,28 @@ hash_free(struct hash_tab *ht)
         }
 }
 
-int getword(FILE *fp, char *buf, int size, int first(int c), int rest(int c))
+int
+getword(FILE *fp, char *buf, int size, int first(int), int rest(int))
 {
         int i = 0, c;
 
         c = getc(fp);
         for ( ; c != EOF; c = getc(fp) )
                 if ( first(c) ) {
-                        if ( i < size-1 )
+                        if ( i < size - 1 )
                                 buf[i++] = c;
                         c = getc(fp);
                         break;
                 }
 
         for ( ; c != EOF && rest(c); c = getc(fp) )
-                if ( i < size-1)
+                if ( i < size - 1 )
                         buf[i++] = c;
 
         if ( i < size )
                 buf[i] = 0;
         else
-                buf[size-1] = 0;
+                buf[size - 1] = 0;
 
         if ( c != EOF )
                 ungetc(c, fp);
@@ -162,15 +163,20 @@ int getword(FILE *fp, char *buf, int size, int first(int c), int rest(int c))
         return c > 0;
 }
 
-int first(int c) {
+int
+first(int c)
+{
         return isalpha(c);
 }
 
-int rest(int c) {
+int
+rest(int c)
+{
         return isalpha(c) || c == '_';
 }
 
-void print(const char *key, T data, void *cl)
+void
+print(const char *key, T data, void *cl)
 {
         fprintf(cl, "%s: %d\n", key, data);
 }
@@ -179,7 +185,7 @@ int
 main()
 {
         struct hash_tab ht[1];
-        char word[100];
+        char            word[100];
 
         hash_init(ht);
 
@@ -195,4 +201,3 @@ main()
 
         hash_free(ht);
 }
-
diff --git a/list.c b/list.c
index 8b18de8..18465b0 100644
--- a/list.c
+++ b/list.c
@@ -13,7 +13,7 @@ typedef int T;
 
 struct list_item {
         struct list_item *next;
-        T data;
+        T                 data;
 };
 
 struct list_item *
@@ -39,7 +39,7 @@ list_delete(struct list_item *list, T data)
 
         for ( struct list_item *p = list; p; p = p->next ) {
                 if ( p->data == data ) {
-                        if ( prev == NULL ) {           /* first element in list? */
+                        if ( prev == NULL ) { /* first element in list? */
                                 list = p->next;
                         }
                         else {
@@ -70,13 +70,13 @@ list_length(struct list_item *list)
 struct list_item *
 list_copy(struct list_item *list)
 {
-        struct list_item *head, **p = &head;
+        struct list_item *head = NULL, **p = &head;
 
         for ( ; list; list = list->next ) {
                 *p = malloc(sizeof **p);
                 if ( *p != NULL ) {
-                        (*p)->data = list->data;        // copy elements
-                        p = &(*p)->next;
+                        (*p)->data = list->data; // copy elements
+                        p          = &(*p)->next;
                 }
                 else
                         ERROR("out of memory");
@@ -91,9 +91,9 @@ list_reverse(struct list_item *list)
         struct list_item *head = NULL, *next;
 
         for ( ; list; list = next ) {
-                next = list->next;
+                next       = list->next;
                 list->next = head;
-                head = list;
+                head       = list;
         }
         return head;
 }
@@ -109,7 +109,7 @@ list_apply(struct list_item *list, void (*visit)(T data, void *cl), void *cl)
 struct list_item *
 list_merge(struct list_item *a, struct list_item *b)
 {
-        struct list_item dummy = { .next = NULL };
+        struct list_item  dummy = { .next = NULL };
         struct list_item *head = &dummy, *c = head;
 
         while ( a != NULL && b != NULL )
@@ -118,7 +118,7 @@ list_merge(struct list_item *a, struct list_item *b)
                 else
                         c->next = b, c = b, b = b->next;
 
-        c->next = ( a != NULL ) ? a : b;
+        c->next = (a != NULL) ? a : b;
 
         return head->next;
 }
@@ -130,7 +130,7 @@ list_sort(struct list_item *c)
                 return c;
 
         struct list_item *a = c,
-                                         *b = c->next;
+                         *b = c->next;
 
         while ( b != NULL && b->next != NULL )
                 c = c->next, b = b->next->next;
@@ -151,7 +151,11 @@ list_free(struct list_item *list)
         }
 }
 
-static void print_data(T data, void *cl) { fprintf(cl, "%d\n", data); }
+static void
+print_data(T data, void *cl)
+{
+        fprintf(cl, "%d\n", data);
+}
 
 int
 main()
@@ -183,13 +187,13 @@ main()
         struct list_item *x = NULL;
         for ( int i = 0; i != COUNT; ++i ) {
                 int r = rand();
-                x = list_add(x, r);
+                x     = list_add(x, r);
         }
 
         puts("start");
         start = clock();
-        x = list_sort(x);
-        printf("Fertig: %.3lf sec\n", (double)(clock() - start) / CLOCKS_PER_SEC);
+        x     = list_sort(x);
+        printf("Fertig: %.3lf sec\n", (double) (clock() - start) / CLOCKS_PER_SEC);
 
         //list_apply(x, print_data);
         printf("Len: %zu\n", list_length(x));
@@ -198,6 +202,3 @@ main()
 
         return EXIT_SUCCESS;
 }
-
-
-
diff --git a/rb.c b/rb.c
index 2a8bff2..1a9e873 100644
--- a/rb.c
+++ b/rb.c
@@ -1,3 +1,7 @@
+/*
+   Implementierung übernommen von: https://web.archive.org/web/20140328232325/http://en.literateprograms.org/Red-black_tree_(C)
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>