final changes completed

bintree.c

@@ -1,128 +1,125 @@
-#include <stdlib.h>
+#include <stdlib.h>          
-#include <stdio.h>
+#include <stdio.h>           
-#include <string.h>
+#include <string.h>          
 
-#include "stack.h"
+#include "stack.h"           
-#include "bintree.h"
+#include "bintree.h"         
 
-static StackNode *push_left(TreeNode *node, StackNode *stack);
+static StackNode *push_left(TreeNode *node, StackNode *stack);  
 
-/* Vergleichsfunktion */
+// Vergleichsfunktion 
 int compareFct(const void *argument1, const void *argument2)
 {
-    int x = *((int *)argument1);
+    int x = *((int *)argument1);                   
-    int y = *((int *)argument2);
+    int y = *((int *)argument2);                   
 
-    if (x < y) return -1;
+    if (x < y) return -1;                          
-    if (x > y) return 1;
+    if (x > y) return 1;                           
-    return 0;
+    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!");
+        perror("Speicher wurde NICHT reserviert!"); 
-        return NULL;
+        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!");
+        perror("Speicher wurde NICHT reserviert!"); 
-        free(node);
+        free(node);                                
-        return NULL;
+        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);
+        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)
+    if (cmp < 0)                                  
     {
-        root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
+        root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate); 
     }
-    else if (cmp > 0)
+    else if (cmp > 0)                             
     {
         root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
     }
-    else
+    else                                          
     {
         if (isDuplicate)
-            *isDuplicate = 1;
+            *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;
+    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)
+    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);                           
-    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;
+        node = node->left;                         
     }
-    return stack;
+    return stack;                                 
 }
 
-/* Gibt gesamten Baum frei */
+// Gibt gesamten Baum frei 
 void clearTree(TreeNode *root)
 {
-    if (root == NULL)
+    if (root == NULL)                             
         return;
 
-    clearTree(root->left);
+    clearTree(root->left);                        
-    clearTree(root->right);
+    clearTree(root->right);                       
-    free(root->data);
+    free(root->data);                             
-    free(root);
+    free(root);                                   
 }
-
+// Liefert Anzahl der Knoten 
-/* Liefert Anzahl der Knoten */
 unsigned int treeSize(const TreeNode *root)
 {
-    if (root == NULL)
+    if (root == NULL)                             
         return 0;
 
-    return 1 + treeSize(root->left) + treeSize(root->right);
+    return 1 + treeSize(root->left) + treeSize(root->right); 
 }

highscores.txt

@@ -1,5 +1,6 @@
 thilo;19753
 thilo;14880
+max;14849
 thilo;14733
 player1;9956
 player2;4988