final changes completed

bintree.c

@@ -1,62 +1,65 @@
+#include <stdlib.h>          
+#include <stdio.h>           
 #include <string.h>          
+
 #include "stack.h"           
 #include "bintree.h"         
 
 static StackNode *push_left(TreeNode *node, StackNode *stack);  
 
+// Vergleichsfunktion 
 int compareFct(const void *argument1, const void *argument2)
 {
     int x = *((int *)argument1);                   
     int y = *((int *)argument2);                   
-    if (x < y)
+
-        return -1;
+    if (x < y) return -1;                          
-    if (x > y)
+    if (x > y) return 1;                           
-        return 1;
     return 0;                                      
 }
 
+// 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!\n");
+        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!\n");
+        perror("Speicher wurde NICHT reserviert!"); 
+        free(node);                                
         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
 }
 
-// Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates
+//Fügt Daten in den Binärbaum ein 
-// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
 {
-    if (root == NULL)
+    if (root == NULL)                              // Wenn Baum leer ist (Ende erreicht)
     {
         if (isDuplicate)
-        {
+            *isDuplicate = 0;                      // Kein Duplikat, da neu eingefügt
-            *isDuplicate = 0;
-        }
         return create_node(data, dataSize);       
     }
 
-    int cmpFCT = compareFCT(data, root->data);
+    int cmp = compareFct(data, root->data);       // Daten mit aktuellem Knoten vergleichen
-    if (cmpFCT < 0)
+
+    if (cmp < 0)                                  
     {
         root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate); 
     }
-    else if (cmpFCT > 0)
+    else if (cmp > 0)                             
     {
         root->right = addToTree(root->right, data, dataSize, compareFct, isDuplicate);
     }
@@ -65,57 +68,58 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
         if (isDuplicate)
             *isDuplicate = 1;                     
     }
-    return root;
+
+    return root;                                  // Wurzel unverändert zurückgeben 
 }
 
-// Iterates over the tree given by root. Follows the usage of strtok. If tree is NULL, the next entry of the last tree given is returned in ordering direction.
+// Inorder-Iterator über den Baum 
-// Use your implementation of a stack to organize the iterator. Push the root node and all left nodes first. On returning the next element,
-// push the top node and push all its left nodes.
 void *nextTreeData(TreeNode *root)
 {
     static StackNode *stack = NULL;               
 
+    /* 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;
 
-    TreeNode *node;
+    TreeNode *node = (TreeNode *)top(stack);     // Oberstes Element vom Stack holen
-    node = 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 
 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;                                 
 }
-// Releases all memory resources (including data copies).
+
+// Gibt gesamten Baum frei 
 void clearTree(TreeNode *root)
 {
-    if (root = NULL) return;
+    if (root == NULL)                             
+        return;
+
     clearTree(root->left);                        
     clearTree(root->right);                       
     free(root->data);                             
     free(root);                                   
 }
-
+// Liefert Anzahl der Knoten 
-// Returns the number of entries in the tree given by root.
 unsigned int treeSize(const TreeNode *root)
 {
     if (root == NULL)                             
-    {
         return 0;
-    }
-    return 1 + treeSize(root->left) + treeSize(root->right);
 
+    return 1 + treeSize(root->left) + treeSize(root->right); 
 }

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];