Makefile angepasst an unit tests. Unit tests geändert

bintree.c

@@ -8,29 +8,177 @@
     * `treeSize`: zählt die Knoten im Baum (rekursiv),
     * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */
 
+
+
+//Hilfsfunktion für addToTree. Erstellt eine treenode.
+static TreeNode* createTreeNode(const void *data, size_t dataSize)
+{
+    TreeNode* newNode = calloc(1, sizeof(TreeNode));
+    if(!newNode)
+    {
+        return NULL;
+    }
+    newNode ->data = malloc(dataSize);
+    if(!newNode->data)
+    {
+        free(newNode);
+        return NULL;
+    }
+    memcpy(newNode -> data, data, dataSize);
+    return newNode;
+}
+
 // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates
-// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
+// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added). (auf 1 wenn duplikat geaddet)
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
 {
-
+    if(!root)
+    {
+        TreeNode *newNode = createTreeNode(data, dataSize);
+        if(isDuplicate != NULL)
+        {
+            *isDuplicate = 0;
+        }
+        return newNode;
+    }
+    int compare = compareFct(data, root-> data);
+    if(compare < 0)
+    {
+        root -> left = addToTree(root -> left, data, dataSize, compareFct, isDuplicate);
+    }
+    else if(compare > 0)
+    {
+        root -> right = addToTree(root -> right, data, dataSize, compareFct, isDuplicate);
+    }
+    else
+    {
+        if(isDuplicate != NULL)
+        {
+            *isDuplicate = 1;
+            return root;
+        }
+        //Konvention: rechts ist >= also das Duplikat wird nach rechts verfrachtet.
+        root -> right = addToTree(root -> right, data, dataSize, compareFct, isDuplicate);
+    }
+    return root;
 }
 
+
 // 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.
 // 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.
+// Wir brauchen eine statische Variable, die überdauernd existiert
+// (Alternativ kann man diese auch global ausserhalb definieren)
+// Die statische Variable (das Gedächtnis) muss außerhalb oder static innerhalb sein
+
+/*
+ * nextTreeData - Iterative In-Order Traversierung (wie strtok)
+ * * Funktionsweise:
+ * 1. Initialisierung (root != NULL):
+ * - Löscht alten Stack.
+ * - Wandert von root so weit nach LINKS wie möglich.
+ * - Pushed alle Knoten auf dem Weg auf den Stack.
+ * -> Das kleinste Element liegt nun oben.
+ * * 2. Iteration (root == NULL):
+ * - Pop: Nimmt oberstes Element vom Stack (aktuell kleinstes).
+ * - Logik: Hat dieses Element einen RECHTEN Nachbarn?
+ * -> JA: Gehe eins nach rechts, dann wieder alles nach LINKS pushen.
+ * -> NEIN: Nichts tun (der Elternknoten liegt schon als nächstes auf dem Stack).
+ * - Gibt die Daten des gepoppten Elements zurück.
+ */
+static StackNode *iteratorStack = NULL;
+
 void *nextTreeData(TreeNode *root)
 {
+    //neuer Baum wird übergeben (root != NULL)
+    if (root != NULL)
+    {
+        // 1. Aufräumen: Falls noch Reste vom letzten Mal da sind
+        if (iteratorStack != NULL) {
+            clearStack(iteratorStack);
+            iteratorStack = NULL;
+        }
+        
+        // 2. Initial befüllen: "Push root and all left nodes"
+        TreeNode *currentNode = root;
+        while (currentNode != NULL)
+        {
+         
+            iteratorStack = push(iteratorStack, currentNode);
+            
+            // Immer weiter nach links absteigen
+            currentNode = currentNode->left;
+        }
+    }
 
+    // PHASE 2: Iteration (Nächsten Wert holen)
+    
+    // Wenn der Stack leer ist (oder leer war), sind wir fertig.
+    if (iteratorStack == NULL)
+    {
+        return NULL; 
+    }
+
+    // 1. Wir schauen uns das oberste Element an (der nächste Knoten in der Reihe)
+    // Wir wissen, dass es ein TreeNode* ist, also casten wir.
+    TreeNode *nodeToReturn = (TreeNode*) top(iteratorStack);
+    
+    // 2. Wir entfernen ihn vom Stack (er ist jetzt "verarbeitet")
+    // Auch hier: pop gibt den neuen Head zurück, also variable aktualisieren!
+    iteratorStack = pop(iteratorStack);
+
+    // 3. Wir retten die Nutzer-Daten (z.B. den Integer), bevor wir weiterwandern
+    void *userData = nodeToReturn->data;
+
+    // 4. Nachfolger suchen (Die Logik für In-Order: Rechts, dann alles links)
+    if (nodeToReturn->right != NULL)
+    {
+        TreeNode *currentNode = nodeToReturn->right;
+        while (currentNode != NULL)
+        {
+            // Auch hier: Stack aktualisieren
+            iteratorStack = push(iteratorStack, currentNode);
+            currentNode = currentNode->left;
+        }
+    }
+
+    // Wir geben die echten Daten zurück (nicht den Knoten, sondern den Inhalt)
+    return userData;
 }
 
 // Releases all memory resources (including data copies).
+
+// Gibt den gesamten Speicher (Knoten + Daten) frei
 void clearTree(TreeNode *root)
 {
+    if (root)
+    {
+        // 2. Rekursion: Erst tief in den Baum absteigen (Post-Order)
+        clearTree(root->left);
+        clearTree(root->right);
 
+        // 3. Jetzt sind die Kinder weg. Wir kümmern uns um den aktuellen Knoten.
+        
+        // Erst den Inhalt (die Datenkopie) löschen!
+        // (free(NULL) ist in C erlaubt, daher müssen wir nicht zwingend auf NULL prüfen,
+        // aber es schadet auch nicht).
+        free(root->data); 
+
+        // 4. Dann den Container (den Knoten selbst) löschen
+        free(root);
+    }
 }
 
 // Returns the number of entries in the tree given by root.
 unsigned int treeSize(const TreeNode *root)
 {
+    // Abbruchbedingung: Wenn kein Knoten da ist, ist die Größe 0
+    if (root == NULL)
+    {
+        return 0;
+    }
 
+    // Rekursionsschritt:
+    // 1 (für den aktuellen Knoten) + alles im linken Baum + alles im rechten Baum
+    return 1 + treeSize(root->left) + treeSize(root->right);
 }

bintree.h

@@ -5,11 +5,11 @@
 
 typedef int (*CompareFctType)(const void *arg1, const void *arg2);
 
-typedef struct node
+typedef struct treenode
 {
     void *data;
-    struct node *left;
+    struct treenode *left;
-    struct node *right;
+    struct treenode *right;
 } TreeNode;
 
 // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates 

makefile

@@ -29,21 +29,32 @@ program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o
 doble : main.o $(program_obj_files)
 	$(CC) $(FLAGS) $^ -o doble
 
-$(program_obj_filesobj_files): %.o: %.c
+$(program_obj_files): %.o: %.c
 	$(CC) -c $(FLAGS) $^ -o $@
 
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
+# Test Stack (JETZT MIT UNITY)
-	echo "needs to be implemented"
+# Wir müssen unity/unity.c mitkompilieren und -Iunity nutzen
+test_stack: test_stack.c stack.o $(unityfolder)/unity.c
+	$(CC) $(FLAGS) -Iunity test_stack.c stack.o $(unityfolder)/unity.c -o test_stack$(EXT)
 
-# --------------------------
+unitTests_stack: test_stack
+	./test_stack$(EXT)
+test_numbers: test_numbers.c numbers.c bintree.c stack.c unity/unity.c
+	gcc -Wall -Wextra -std=c99 -Iunity \
+	    -o test_numbers \
+	    test_numbers.c numbers.c bintree.c stack.c unity/unity.c
+unitTests_number: test_numbers
+	./test_numbers
+
+#-------------------------
 # Clean
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)
-	del /f *.o doble
+	del /f *.o doble.exe test_stack.exe test_numbers.exe
 else
 	rm -f *.o doble
 endif

numbers.c

@@ -11,16 +11,93 @@
   * Duplizieren eines zufälligen Eintrags im Array.
   * in `getDuplicate()`: Sortieren des Arrays und Erkennen der doppelten Zahl durch Vergleich benachbarter Elemente. */
 
-// Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
+//Vergleichsfunktion von qsort
-// Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
+static int compareUnsignedInt(const void *a, const void *b)
-// creating random numbers.
-unsigned int *createNumbers(unsigned int len)
 {
+const unsigned int *x = (const unsigned int *)a;
+   const unsigned int *y = (const unsigned int *)b;
 
+   if (*x < *y) return -1;
+   if (*x > *y) return 1;
+   return 0;
 }
 
-// Returns only the only number in numbers which is present twice. Returns zero on errors.
+//Mischen des Arrays
+static void shuffleArray(unsigned int *array, unsigned int n)
+{
+   if (n > 1)
+   {
+       for (unsigned int i = n - 1; i > 0; i--)
+       {
+           unsigned int j = rand() % (i + 1);
+           unsigned int temp = array[i];
+           array[i] = array[j];
+           array[j] = temp;
+       }
+   }
+}
+//Wenn weniger als zwei Zahlen
+unsigned int *createNumbers(unsigned int len)
+{
+   if (len < 2) return NULL;
+
+//Dynamisches Array
+   unsigned int *numbers = malloc(len * sizeof(unsigned int));
+   if (numbers == NULL) return NULL;
+//Variabelen für den Binärbaum
+   TreeNode *root = NULL;
+   int isDuplicate = 0;
+   unsigned int count = 0;
+
+
+   while (count < len - 1)
+   {   //Zufallszahlen generieren
+       unsigned int value = (rand() % (2 * len)) + 1;
+
+
+       root = addToTree(root, &value, sizeof(unsigned int), compareUnsignedInt, &isDuplicate);
+
+       if (isDuplicate == 0)
+       {   //in array schreiben falls kein Duplikat
+           numbers[count] = value;
+           count++;
+       }
+
+   }
+   //Duplikat erzeugen
+   unsigned int randomIndex = rand() % (len - 1);
+   unsigned int duplicateValue = numbers[randomIndex];
+   numbers[len - 1] = duplicateValue;
+   root = addToTree(root, &duplicateValue, sizeof(unsigned int), compareUnsignedInt, NULL);
+   //Array mischen damit duplikat nicht am Ende immer ist
+   shuffleArray(numbers, len);
+
+   clearTree(root);
+   return numbers;
+}
+//get Duplicate
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
+ if (numbers == NULL || len < 2) {
+   return 0;
+ }
+//Kopie vom Array anlegen
+ unsigned int *copy = malloc(len * sizeof(unsigned int));
 
+ if (copy == NULL) {
+   return 0;
+ }
+ memcpy(copy, numbers, len * sizeof(unsigned int));
+ qsort(copy, len, sizeof(unsigned int), compareUnsignedInt);
+ unsigned int duplicate = 0;
+//Duplikat finden
+ for (unsigned int i = 0; i + 1 < len; ++i) {
+   if (copy[i] == copy[i + 1]) {
+     duplicate = copy[i];
+     break;
+   }
+ }
+//Speicher freigeben
+ free(copy);
+ return duplicate;
 }

stack.c

@@ -8,26 +8,69 @@
     * `clearStack`: gibt den gesamten Speicher frei. */
 
 // Pushes data as pointer onto the stack.
+
+// Hilfsfunktion
+static StackNode *createStackNode(void *data)
+{
+    // 1. Container reservieren
+    StackNode *newNode = calloc(1, sizeof(StackNode));
+    if(!newNode) return NULL;
+
+    // 2. WICHTIG: Wir speichern nur den Zeiger (die Adresse)!
+    // Wir machen KEIN zweites malloc für die Daten.
+    // Der Stack "besitzt" die Daten nicht, er referenziert sie nur.
+    newNode->data = data; 
+    
+    newNode->nextNode = NULL;
+    return newNode;
+}
+
 StackNode *push(StackNode *stack, void *data)
 {
+    // Neue Node erstellen
+    StackNode *newNode = createStackNode(data);
+    if (!newNode) {
+        return stack; // Fehlerfall: Stack bleibt unverändert (oder Fehlerbehandlung)
+    }
 
+    // Verkettung: Die neue Node zeigt auf den alten Kopf
+    newNode->nextNode = stack;
+
+    // Die neue Node ist der neue Kopf (Rückgabewert)
+    return newNode; 
 }
 
 // Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
 // freed by caller.)
 StackNode *pop(StackNode *stack)
 {
-
+    if(stack)
+    {
+        StackNode* tempNode = stack -> nextNode;
+        free(stack);
+        return tempNode;
+    }
+    return stack;
 }
 
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
-
+    if(stack)
+    {
+        return stack ->data;
+    }
+    return NULL;
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode *stack)
 {
-
+    StackNode *temp = NULL;
+    while(stack)
+    {
+        temp = stack -> nextNode;
+        free(stack);
+        stack = temp;
+    }
 }

stack.h

@@ -9,6 +9,12 @@ The latest element is taken from the stack. */
 
 //TODO: passenden Datentyp als struct anlegen
 
+typedef struct node
+{
+    void *data;
+    struct node* nextNode;
+} StackNode;
+
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data);
 

test_numbers.c

@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <time.h>
+
+#include "unity/unity.h"
+#include "numbers.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+static unsigned int countOccurrences(const unsigned int *numbers, unsigned int len, unsigned int value)
+{
+    unsigned int count = 0;
+    for (unsigned int i = 0; i < len; ++i) {
+        if (numbers[i] == value) {
+            count++;
+        }
+    }
+    return count;
+}
+
+void test_createNumbers_returns_non_null(void)
+{
+    unsigned int len = 20;
+    unsigned int *numbers = createNumbers(len);
+
+    TEST_ASSERT_NOT_NULL(numbers);
+
+    free(numbers);
+}
+
+void test_createNumbers_value_range(void)
+{
+    unsigned int len = 30;
+    unsigned int *numbers = createNumbers(len);
+
+    TEST_ASSERT_NOT_NULL(numbers);
+
+    for (unsigned int i = 0; i < len; ++i) {
+        TEST_ASSERT_TRUE(numbers[i] >= 1);
+        TEST_ASSERT_TRUE(numbers[i] <= 2 * len);
+    }
+
+    free(numbers);
+}
+
+void test_getDuplicate_finds_exactly_one_duplicate(void)
+{
+    unsigned int len = 25;
+    unsigned int *numbers = createNumbers(len);
+
+    TEST_ASSERT_NOT_NULL(numbers);
+
+    unsigned int duplicate = getDuplicate(numbers, len);
+    TEST_ASSERT_NOT_EQUAL_UINT(0, duplicate);
+
+    unsigned int occurrences =
+        countOccurrences(numbers, len, duplicate);
+
+    TEST_ASSERT_EQUAL_UINT(2, occurrences);
+
+    free(numbers);
+}
+
+void test_error_cases(void)
+{
+    TEST_ASSERT_NULL(createNumbers(0));
+    TEST_ASSERT_NULL(createNumbers(1));
+
+    TEST_ASSERT_EQUAL_UINT(0, getDuplicate(NULL, 10));
+
+    unsigned int oneElement[1] = { 42 };
+    TEST_ASSERT_EQUAL_UINT(0, getDuplicate(oneElement, 1));
+}
+
+int main(void)
+{
+    srand((unsigned int) time(NULL));
+
+    UNITY_BEGIN();
+
+    RUN_TEST(test_createNumbers_returns_non_null);
+    RUN_TEST(test_createNumbers_value_range);
+    RUN_TEST(test_getDuplicate_finds_exactly_one_duplicate);
+    RUN_TEST(test_error_cases);
+
+    return UNITY_END();
+}

test_stack.c

@@ -0,0 +1,72 @@
+#include <stdlib.h>
+#include "unity.h"
+#include "stack.h"
+
+// Globale Variablen für den Test (optional, aber praktisch hier)
+StackNode *stack = NULL;
+int *a;
+int *b;
+
+void setUp(void) {
+    stack = NULL;
+    // Wir reservieren Speicher für jedes Test-Szenario frisch
+    a = malloc(sizeof(int));
+    b = malloc(sizeof(int));
+    *a = 10;
+    *b = 20;
+}
+
+void tearDown(void) {
+    // Aufräumen nach jedem Test
+    if (stack != NULL) {
+        clearStack(stack);
+        stack = NULL;
+    }
+    // Falls der Stack die Daten NICHT freest, müssen wir es tun:
+    // Hinweis: Wenn clearStack die Daten freest, darfst du hier a und b nicht free-en!
+    // Ich gehe davon aus, der Stack freest die Daten NICHT.
+    free(a);
+    free(b);
+}
+
+void test_push_and_top(void) {
+    stack = push(stack, a);
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_INT(10, *(int*)top(stack));
+
+    stack = push(stack, b);
+    TEST_ASSERT_EQUAL_INT(20, *(int*)top(stack));
+}
+
+void test_pop_logic(void) {
+    // Vorbereitung
+    stack = push(stack, a);
+    stack = push(stack, b);
+
+    // Test Pop 1
+    stack = pop(stack);
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_INT(10, *(int*)top(stack));
+
+    // Test Pop 2 (Stack sollte leer werden)
+    stack = pop(stack);
+    TEST_ASSERT_NULL(stack);
+}
+
+void test_clearStack(void) {
+    stack = push(stack, a);
+    stack = push(stack, b);
+
+    clearStack(stack);
+    stack = NULL; // Muss im Code manuell gemacht werden, wenn clearStack void ist
+
+    TEST_ASSERT_NULL(stack);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+    RUN_TEST(test_push_and_top);
+    RUN_TEST(test_pop_logic);
+    RUN_TEST(test_clearStack);
+    return UNITY_END();
+}