final changes completed

bintree.c

@@ -7,7 +7,7 @@
 
 static StackNode *push_left(TreeNode *node, StackNode *stack);  
 
-/* Vergleichsfunktion */
+// Vergleichsfunktion 
 int compareFct(const void *argument1, const void *argument2)
 {
     int x = *((int *)argument1);                   
@@ -18,17 +18,17 @@ int compareFct(const void *argument1, const void *argument2)
     return 0;                                      
 }
 
-/* Erzeugt einen neuen Baumknoten mit Datenkopie */
+// Erzeugt einen neuen Baumknoten mit Datenkopie 
 static TreeNode *create_node(const void *data, size_t data_size)
 {
-    TreeNode *node = malloc(sizeof(TreeNode));
+    TreeNode *node = malloc(sizeof(TreeNode));    // Speicher für neuen Knoten reservieren
     if (!node)
     {
         perror("Speicher wurde NICHT reserviert!"); 
         return NULL;                               
     }
 
-    node->data = malloc(data_size);
+    node->data = malloc(data_size);               // Speicher für Knotendaten reservieren
     if (!node->data)
     {
         perror("Speicher wurde NICHT reserviert!"); 
@@ -36,25 +36,24 @@ static TreeNode *create_node(const void *data, size_t data_size)
         return NULL;                               
     }
 
-    memcpy(node->data, data, data_size);
+    memcpy(node->data, data, data_size);          // Daten in neuen Speicher kopieren
-    node->left = NULL;
+    node->left = NULL;                             // Linken Kindzeiger initialisieren
-    node->right = NULL;
+    node->right = NULL;                            // Rechten Kindzeiger initialisieren
 
-    return node;
+    return node;                                   // Zeiger auf neuen Knoten zurückgeben
 }
 
-/* Fügt Daten in den Binärbaum ein */
+//Fügt Daten in den Binärbaum ein 
-TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize,
+TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
-                    CompareFctType compareFct, int *isDuplicate)
 {
-    if (root == NULL)
+    if (root == NULL)                              // Wenn Baum leer ist (Ende erreicht)
     {
         if (isDuplicate)
-            *isDuplicate = 0;
+            *isDuplicate = 0;                      // Kein Duplikat, da neu eingefügt
         return create_node(data, dataSize);       
     }
 
-    int cmp = compareFct(data, root->data);
+    int cmp = compareFct(data, root->data);       // Daten mit aktuellem Knoten vergleichen
 
     if (cmp < 0)                                  
     {
@@ -70,43 +69,42 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize,
             *isDuplicate = 1;                     
     }
 
-    return root;
+    return root;                                  // Wurzel unverändert zurückgeben 
 }
 
-/* Inorder-Iterator über den Baum */
+// Inorder-Iterator über den Baum 
 void *nextTreeData(TreeNode *root)
 {
     static StackNode *stack = NULL;               
 
-    /* Neuer Start → linken Pfad auf Stack legen */
+    /* Linken Pfad auf Stack legen */
     if (root != NULL)
-        stack = push_left(root, stack);
+        stack = push_left(root, stack);           // Linken Pfad ab root auf Stack legen
 
     if (stack == NULL)                            
         return NULL;
 
-    /* TOP lesen, dann POP */
+    TreeNode *node = (TreeNode *)top(stack);     // Oberstes Element vom Stack holen
-    TreeNode *node = (TreeNode *)top(stack);
     stack = pop(stack);                           
 
-    if (node->right != NULL)
+    if (node->right != NULL)                      // Wenn rechter Teilbaum existiert
-        stack = push_left(node->right, stack);
+        stack = push_left(node->right, stack);   // Linken Pfad vom rechten Kind auf Stack legen
 
-    return node->data;
+    return node->data;                            // Daten des Knotens zurückgeben
 }
 
-/* Hilfsfunktion: linken Pfad auf Stack legen */
+// Hilfsfunktion: linken Pfad auf Stack legen 
 static StackNode *push_left(TreeNode *node, StackNode *stack)
 {
-    while (node != NULL)
+    while (node != NULL)                          // Solange linkes Kind existiert
     {
-        stack = push(stack, node);
+        stack = push(stack, node);                // Knoten auf Stack legen
         node = node->left;                         
     }
     return stack;                                 
 }
 
-/* Gibt gesamten Baum frei */
+// Gibt gesamten Baum frei 
 void clearTree(TreeNode *root)
 {
     if (root == NULL)                             
@@ -117,8 +115,7 @@ void clearTree(TreeNode *root)
     free(root->data);                             
     free(root);                                   
 }
-
+// Liefert Anzahl der Knoten 
-/* Liefert Anzahl der Knoten */
 unsigned int treeSize(const TreeNode *root)
 {
     if (root == NULL)                             

highscores.txt

@@ -1,2 +1,10 @@
+thilo;19753
+thilo;14880
+max;14849
+thilo;14733
+player1;9956
+player2;4988
+player1;4980
 player_name;4980
+player2;4885
 player1;3999

makefile

@@ -41,18 +41,25 @@ stack_test_objects = $(stack_test_sources:.c=.o)
 numbers_test_sources = test_numbers.c numbers.c
 numbers_test_objects = $(numbers_test_sources:.c=.o)
 
+bintree_test_sources = test_bintree.c bintree.c
+bintree_test_objects = $(bintree_test_sources:.c=.o)
+
 stack_test_runner: $(stack_test_objects)
 	$(CC) $(FLAGS) $^ -o $@
 
 numbers_test_runner: $(numbers_test_objects)
 	$(CC) $(FLAGS) $^ -o $@
 
-unitTests: stack_test_runner numbers_test_runner
+bintree_test_runner: $(bintree_test_objects)
+	$(CC) $(FLAGS) $^ -o $@
+
+unitTests: stack_test_runner numbers_test_runner bintree_test_runner
 	@echo "============================="
 	@echo "Running Unit Tests..."
 	@echo "============================="
 	./stack_test_runner
 	./numbers_test_runner
+	./bintree_test_runner
 	@echo "============================="
 	@echo "Unit Tests Finished."
 	@echo "============================="

numbers.c

@@ -73,12 +73,37 @@ unsigned int *createNumbers(unsigned int len)
 
 	srand(time(NULL));
 
-	for (unsigned int i = 0; i < len; i++) 
+	/*for (unsigned int i = 0; i < len; i++) 
 	{
 		array[i] = rand() % (2*len) + 1;
 	}
 	
-	//TODO: sicherstellen, dass im Array keine doppelten Zahlen vorhanden sind (Max)
+	*/
+
+	TreeNode *root = NULL;
+    int isDuplicate;
+    unsigned int value;
+    unsigned int i = 0;
+
+    srand(time(NULL));
+
+    while (i < len)
+    {
+        value = rand() % (2 * len) + 1;
+
+        root = addToTree(root, &value, sizeof(unsigned int), compareFct, &isDuplicate);
+
+        if (isDuplicate == 0)
+        {
+            array[i] = value;
+            i++;
+        }
+        // Bei Duplikat: nochmal versuchen, kein Inkrement
+    }
+
+    clearTree(root);
+
+	
 
 	position = rand() % len;
 	duplicate_value = array[position];
@@ -86,7 +111,7 @@ unsigned int *createNumbers(unsigned int len)
 	do
 	{
 		pos_dup = rand() % len;
-	} while (pos_dup = duplicate_value);
+	} while (pos_dup == position);
 	
 	array[pos_dup] = array[position];