unittests from makefile is done

.gitignore

@@ -0,0 +1 @@
+.idea/

bintree.c

@@ -1,3 +1,4 @@
+
 #include <string.h>
 #include "stack.h"
 #include "bintree.h"
@@ -12,25 +13,100 @@
 // 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)
 {
+  //*******************  Prüfen ob wir kein Nullzeiger oder Null speicher haben
+    if (root == NULL) {
+        // Kein Knoten vorhanden : neuer Knoten wird erstellt
+        TreeNode *node = malloc(sizeof(TreeNode));
+        if (!node)
+          return NULL;
+        node->data = malloc(dataSize);
+        if (!node->data) {
+            free(node);
+            return NULL;
+        }
+  //*******************   Ende von Prüfungen
 
+        memcpy(node->data, data, dataSize);
+        node->left = NULL;
+        node->right = NULL;
+
+        if (isDuplicate != NULL)
+          *isDuplicate = 0;
+        return node;
+    }
+
+    int cmp = compareFct(data, root->data);
+
+    if (cmp == 0) {
+        if (isDuplicate)
+          *isDuplicate = 1;
+        return root;  // Ignorieren, keine Änderung
+    }
+
+    if (cmp < 0)
+        root->left = addToTree(root->left, data, dataSize, compareFct, isDuplicate);
+    else
+        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.
-void *nextTreeData(TreeNode *root)
-{
+void *nextTreeData(TreeNode *root) {
 
+    // static stack : wie strtok interner Zustand
+    static StackNode *stack = NULL;
+
+    if (root != NULL) {
+        // neuer Durchlauf : alten Stack löschen
+        clearStack(stack);
+        stack = NULL;
+
+        // alle linken Knoten pushen
+        TreeNode *curr = root;
+        while (curr != NULL) {
+            stack = push(stack, curr);
+            curr = curr->left;
+        }
+    }
+
+    if (stack == NULL)
+        return NULL;   // nichts mehr da
+
+    // obersten Knoten holen
+    TreeNode *node = (TreeNode *) top(stack);
+    stack = pop(stack);
+
+    // rechten Teilbaum durchsuchen (und alle linken davon)
+    TreeNode *curr = node->right;
+    while (curr != NULL) {
+        stack = push(stack, curr);
+        curr = curr->left;
+    }
+
+    return node->data;
 }
 
 // Releases all memory resources (including data copies).
-void clearTree(TreeNode *root)
-{
-
+void clearTree(TreeNode *root) {
+    if (root == NULL)
+        return;
+//erstens in die tiefsten Ebenen gehen
+    clearTree(root->left);
+    clearTree(root->right);
+// dann zeiger auf Datei löschen
+    free(root->data);
+//Und am ende element des Baums löschen
+    free(root);
 }
 
-// Returns the number of entries in the tree given by root.
-unsigned int treeSize(const TreeNode *root)
-{
 
-}
+// 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);
+}

highscores.txt

@@ -1 +1,10 @@
+the_king;43984
+Regis;18924
+player_name;9929
+Kamto;7946
+player_name;5987
+player_1;4989
+Warren;4986
+player_name;4983
 player1;3999
+player_name;2991

makefile

@@ -35,8 +35,20 @@ $(program_obj_filesobj_files): %.o: %.c
 # --------------------------
 # Unit Tests
 # --------------------------
-unitTests:
-	echo "needs to be implemented"
+
+unitTests: test_numbers test_stack
+
+test_numbers: test_numbers.o stack.o bintree.o numbers.o
+	$(CC) $(FLAGS) $^ -o test_numbers
+
+test_numbers.o: test_numbers.c
+	$(CC) -c $(FLAGS) $< -o $@
+
+test_stack: test_stack.o stack.o
+	$(CC) $(FLAGS) $^ -o test_stack
+
+test_stack.o:  test_stack.c
+	$(CC) -c $(FLAGS) $< -o $@
 
 # --------------------------
 # Clean

numbers.c

@@ -14,13 +14,74 @@
 // Returns len random numbers between 1 and 2x len in random order which are all different, except for two entries.
 // Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
 // creating random numbers.
-unsigned int *createNumbers(unsigned int len)
-{
+unsigned int *createNumbers(unsigned int len) {
 
+    if (len < 2)
+      return NULL;
+
+    unsigned int *numbers = malloc(len * sizeof(unsigned int));
+    if (!numbers)
+      return NULL;
+
+    srand((unsigned int)time(NULL));
+
+    for (unsigned int i = 0; i < len - 1; i++) {
+        unsigned int n;
+        int duplicate;
+        do {
+            duplicate = 0;
+            n = rand() % (2 * len) + 1;
+
+            for (unsigned int j = 0; j < i; j++) {
+                if (numbers[j] == n) {
+                    duplicate = 1;
+                    break;
+                }
+            }
+        } while (duplicate);
+
+        numbers[i] = n;
+    }
+
+    // zufälliges Duplikat am Ende
+    unsigned int idx1 = rand() % (len - 1);
+    numbers[len - 1] = numbers[idx1];
+
+    return numbers;
 }
 
-// Returns only the only number in numbers which is present twice. Returns zero on errors.
-unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
-{
 
-}
+// Returns only the only number in numbers which is present twice. Returns zero on errors.
+unsigned int getDuplicate(const unsigned int numbers[], unsigned int len) {
+
+    if (!numbers || len < 2) return 0;
+
+    // Kopie erstellen, damit Original nicht verändert wird
+    unsigned int *copy = malloc(len * sizeof(unsigned int));
+    if (!copy) return 0;
+    memcpy(copy, numbers, len * sizeof(unsigned int));
+
+    // Einfacher Bubble Sort oder Insert Sort direkt in dieser Funktion
+    // damit wir keine Hilfsfunktionen brauchen
+    for (unsigned int i = 0; i < len - 1; i++) {
+        for (unsigned int j = 0; j < len - i - 1; j++) {
+            if (copy[j] > copy[j + 1]) {
+                unsigned int tmp = copy[j];
+                copy[j] = copy[j + 1];
+                copy[j + 1] = tmp;
+            }
+        }
+    }
+
+    // benachbarte Elemente vergleichen
+    for (unsigned int i = 0; i < len - 1; i++) {
+        if (copy[i] == copy[i + 1]) {
+            unsigned int dup = copy[i];
+            free(copy);
+            return dup;
+        }
+    }
+
+    free(copy);
+    return 0;
+}

numbers.h

@@ -8,5 +8,4 @@ unsigned int *createNumbers(unsigned int len);
 
 // Returns only the only number in numbers which is present twice. Returns zero on errors.
 unsigned int getDuplicate(const unsigned int *numbers, unsigned int len);
-
 #endif

stack.c

@@ -10,24 +10,43 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
-
+StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));
+if(newNode == NULL)
+  return NULL;
+newNode->data = data;
+newNode->next = stack;
+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 == NULL)
+        return NULL;
 
+    StackNode *newTop = stack->next;
+    free(stack);
+    return newTop;
 }
 
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
-
+if (stack == NULL)
+  return NULL;
+return stack->data;
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode *stack)
 {
+StackNode *current = stack;
 
+while (current != NULL)
+  {
+  StackNode *next = current->next;
+  free(current);
+  current = next;
+  }
 }

stack.h

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

test_numbers.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "numbers.h"
+
+int main() {
+    unsigned int len = 10; // Beispielgröße
+    unsigned int *numbers = createNumbers(len);
+
+    if (!numbers) {
+        printf("Fehler: Konnte Zahlen nicht erzeugen.\n");
+        return 1;
+    }
+
+    // 1 Test: Alle Zahlen ausgeben
+    printf("Erzeugtes Array:\n");
+    for (unsigned int i = 0; i < len; i++) {
+        printf("%u ", numbers[i]);
+    }
+    printf("\n");
+
+    // 2 Test: Prüfen, ob genau ein Duplikat vorhanden ist
+    unsigned int duplicate = getDuplicate(numbers, len);
+    if (duplicate == 0) {
+        printf("Fehler: Kein Duplikat gefunden.\n");
+    } else {
+        printf("Gefundenes Duplikat: %u\n", duplicate);
+    }
+
+    // 3 Test: Prüfen, ob nur ein Duplikat existiert
+    unsigned int count = 0;
+    for (unsigned int i = 0; i < len; i++) {
+        if (numbers[i] == duplicate)
+            count++;
+    }
+    if (count == 2) {
+        printf("Test bestanden: Genau ein Duplikat vorhanden.\n");
+    } else {
+        printf("Test fehlgeschlagen: Duplikatanzahl = %u\n", count);
+    }
+
+    // Speicher freigeben
+    free(numbers);
+
+    return 0;
+}

test_stack.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "stack.h"
+
+int main()
+{
+    StackNode *stack = NULL;
+
+    // Test 1: Push
+    int *a = malloc(sizeof(int));  // erstellt Daten
+    *a = 10;
+    int *b = malloc(sizeof(int));
+    *b = 20;
+    int *c = malloc(sizeof(int));
+    *c = 30;
+
+    stack = push(stack, a); //legt ein Element oben auf den Stack
+    stack = push(stack, b);
+    stack = push(stack, c);
+
+    // Test 2: Top
+    printf("Top (soll 30 sein): %d\n", *((int*)top(stack))); // Zeigt den Top vom Stack
+
+    // Test 3: Pop
+    stack = pop(stack);  // entfernt 30
+    free(c);
+
+    printf("Top nach pop (soll 20 sein): %d\n", *(int*)top(stack)); // // Zeigt den Top vom Stack
+
+    // Test 4: Nochmal pop
+    stack = pop(stack);  // entfernt 20
+    free(b);
+
+    printf("Top nach pop (soll 10 sein): %d\n", *(int*)top(stack));
+
+    // Test 5: clearStack
+    clearStack(stack);  //  gibt den gesamten Speicher frei
+
+    return 0;
+}