presented code

bintree.c

@@ -51,26 +51,32 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
 
 TreeNode *addToTreeRec(TreeNode *currentNode, TreeNode *newNode, CompareFctType compareFct, int *isDuplicate, const int root)
 {
-    if ((currentNode == NULL))
+    if (currentNode == NULL)
     {
         if ((isDuplicate == NULL) || root)
         {
+            if (isDuplicate != NULL)
+            {
+                *isDuplicate = 0;
+            }
+            
             return newNode;
         }
         else
         {
+            *isDuplicate = 0;
             return currentNode;
         }
     }
-    else if ((compareFct(currentNode->data, newNode->data) < 0))
+    else if (compareFct(currentNode->data, newNode->data) < 0)
     {
         currentNode->left   = addToTreeRec(currentNode->left, newNode, compareFct, isDuplicate, 0);
     }
-    else if ((compareFct(currentNode->data, newNode->data) > 0))
+    else if (compareFct(currentNode->data, newNode->data) > 0)
     {
         currentNode->right  = addToTreeRec(currentNode->right, newNode, compareFct, isDuplicate, 0);
     }
-    else if ((compareFct(currentNode->data, newNode->data) == 0))
+    else if (compareFct(currentNode->data, newNode->data) == 0)
     {
         if (isDuplicate == NULL)
         {
@@ -101,13 +107,13 @@ void *nextTreeData(TreeNode *root)
     {
         // Add tree to stack so that bigest entry is ontop
         stackRoot       = nextTreeDataRec(root, stackRoot);
-        pointerToReturn = stackRoot;
+        pointerToReturn = top(stackRoot);
     }
     else
     {
         // return current top entry and then pop that top entry
-        pointerToReturn = top(stackRoot);
         stackRoot       = pop(stackRoot);
+        pointerToReturn = top(stackRoot);
     }
 
     

bintreeTests.c

@@ -115,7 +115,7 @@ void test_nextTreeDataReturnsNextDataCorrectly(void)
     // check if nextTreeData returns Data correctly
     TEST_ASSERT_NOT_NULL(entry);
 
-    TEST_ASSERT_EQUAL(score7, *(int *)nextTreeData(NULL));
+    TEST_ASSERT_EQUAL(score7, *(int *)entry);
     TEST_ASSERT_EQUAL(score3, *(int *)nextTreeData(NULL));
     TEST_ASSERT_EQUAL(score6, *(int *)nextTreeData(NULL));
     TEST_ASSERT_EQUAL(score1, *(int *)nextTreeData(NULL));

numbers.c

@@ -23,13 +23,22 @@ static int compareUInt(const void *a, const void *b)
     if (A > B) return 1;
     return 0;
 }
-// Sortiervergleich für qsort
-int compareQsort(const void *a, const void *b)
+
+static int existsInTree(TreeNode *root, unsigned int value)
 {
-    unsigned int A = *(const unsigned int*)a;
-    unsigned int B = *(const unsigned int*)b;
-    if (A < B) return -1;
-    if (A > B) return +1;
+    if (!root) return 0;
+
+    unsigned int *data;
+
+    // Traversierung initialisieren
+    data = nextTreeData(root);
+
+    do    
+    {
+        if (*data == value)
+            return 1;
+    } while ((data = nextTreeData(NULL)) != NULL);
+
     return 0;
 }
 
@@ -39,56 +48,50 @@ unsigned int *createNumbers(unsigned int len)
 
     srand((unsigned int)time(NULL));
 
-    // Speicher für das Array
     unsigned int *numbers = malloc(sizeof(unsigned int) * len);
     if (!numbers) return NULL;
 
-    TreeNode *root = NULL;        // Baumwurzel
+    TreeNode *root = NULL;
     unsigned int value;
-    int isDuplicate;
 
-    //Array mit eindeutigen Zufallszahlen füllen
+    // Array mit eindeutigen Zufallszahlen füllen
     for (unsigned int i = 0; i < len; i++)
     {
-        while (1)
+        do
         {
-            value = (rand() % (2 * len)) + 1; // Zufallszahl 1..2*len
-            isDuplicate = 0;
+            value = (rand() % (2 * len)) + 1;
+        }
+        while (existsInTree(root, value));
 
-            TreeNode *newRoot = addToTree(
+        // Baum wie highscore benutzen (immer NULL)
+        root = addToTree(
             root,
             &value,
             sizeof(unsigned int),
             compareUInt,
-                &isDuplicate
+            NULL
         );
 
-            if (!isDuplicate)
-            {
-                // Neue Zahl - akzeptieren
-                root = newRoot;
         numbers[i] = value;
-                break;
-            }
-            // Sonst neue Zahl generieren
-        }
     }
 
-    //genau eine Zufallszahl duplizieren
+    // genau eine Zufallszahl duplizieren
     unsigned int idx1 = rand() % len;
-    unsigned int idx2 = rand() % len;
+    unsigned int idx2;
 
-    while (idx2 == idx1)
+    do
+    {
         idx2 = rand() % len;
+    }
+    while (idx2 == idx1);
 
     numbers[idx2] = numbers[idx1];
 
-    // Baum wieder freigeben
     clearTree(root);
-
     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)
 {
@@ -101,7 +104,7 @@ unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
     memcpy(copy, numbers, len * sizeof(unsigned int));
 
     // Sortieren
-    qsort(copy, len, sizeof(unsigned int), compareQsort);
+    qsort(copy, len, sizeof(unsigned int), compareUInt);
 
     // Doppelte Zahl finden
     unsigned int duplicate = 0;

test_numbers.c

@@ -14,60 +14,36 @@ void tearDown(void) {
     // gehört zu unit-Grundaufbau
 }
 
-// prüft, ob ein Array nur EIN Duplikat enthält
-static int countDuplicates(const unsigned int *arr, unsigned int len) {
-    int count = 0;
-    for (unsigned int i = 0; i < len; i++) {
-        for (unsigned int j = i + 1; j < len; j++) {
-            if (arr[i] == arr[j]) {
-                count++;
-            }
-        }
-    }
-    return count;
-}
-
-// Prüfen, ob createNumbers ein korrektes Array liefert
-static void test_createNumbers_basic(void)
+// Testet, ob createNumbers ein gültiges Array erzeugt
+// und genau ein Duplikat enthalten ist
+void test_createNumbers_basic(void)
 {
-    unsigned int len = 100;
-    unsigned int *arr = createNumbers(len);
+    unsigned int len = 10;
+    unsigned int *numbers = createNumbers(len);
 
-    TEST_ASSERT_NOT_NULL(arr);          // prüft ob Speicher korrekt
+    // Array muss existieren
+    TEST_ASSERT_NOT_NULL(numbers);
 
-    // Prüfen: Länge stimmt
+    // Es muss genau EIN Duplikat geben
+    unsigned int duplicate = getDuplicate(numbers, len);
+    TEST_ASSERT_NOT_EQUAL(0, duplicate);
 
-    // Prüfen: Array enthält GENAU EIN Duplikat
-    int dupCount = countDuplicates(arr, len);
-    TEST_ASSERT_EQUAL_INT(1, dupCount);
-
-    free(arr);
+    free(numbers);
 }
 
-// TEST 2: Prüfen, ob getDuplicate die richtige doppelte Zahl erkennt
-static void test_getDuplicate_correctValue(void)
+/// Testet, ob getDuplicate die korrekte doppelte Zahl erkennt
+
+void test_getDuplicate_correctValue(void)
 {
-    unsigned int len = 200;
-    unsigned int *arr = createNumbers(len);
+    unsigned int numbers[] = {1, 3, 5, 7, 3};
+    unsigned int len = 5;
 
-    TEST_ASSERT_NOT_NULL(arr);
+    unsigned int dup = getDuplicate(numbers, len);
 
-    unsigned int duplicate = getDuplicate(arr, len);
-
-    // Manuelle Kontrolle: Der gefundene Wert muss tatsächlich doppelt vorkommen
-    int occurrences = 0;
-    for (unsigned int i = 0; i < len; i++) {
-        if (arr[i] == duplicate) {
-            occurrences++;
-        }
-    }
-
-    TEST_ASSERT_EQUAL_INT(2, occurrences);
-
-    free(arr);
+    TEST_ASSERT_EQUAL(3, dup);
 }
 
-// TEST 3: getDuplicate gibt 0 aus bei Fehlern
+// Testet Fehlerfälle von getDuplicate
 static void test_getDuplicate_errors(void)
 {
     TEST_ASSERT_EQUAL_UINT(0, getDuplicate(NULL, 10));