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,5 +1,6 @@
 thilo;19753
 thilo;14880
+max;14849
 thilo;14733
 player1;9956
 player2;4988