diff --git a/bintree.o b/bintree.o
index 1b42584..8515a53 100644
Binary files a/bintree.o and b/bintree.o differ
diff --git a/highscores.txt b/highscores.txt
index 4edd5a7..9a6b2a2 100644
--- a/highscores.txt
+++ b/highscores.txt
@@ -1 +1,3 @@
+�o�;0
+test;9238
 player1;3999
diff --git a/numbers.c b/numbers.c
index ec96255..f41573a 100644
--- a/numbers.c
+++ b/numbers.c
@@ -23,13 +23,21 @@ 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
+    nextTreeData(root);
+
+    while ((data = nextTreeData(NULL)) != NULL)
+    {
+        if (*data == value)
+            return 1;
+    }
     return 0;
 }
 
@@ -39,56 +47,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;
-
-            TreeNode *newRoot = addToTree(
-                root,
-                &value,
-                sizeof(unsigned int),
-                compareUInt,
-                &isDuplicate
-            );
-
-            if (!isDuplicate)
-            {
-                // Neue Zahl - akzeptieren
-                root = newRoot;
-                numbers[i] = value;
-                break;
-            }
-            // Sonst neue Zahl generieren
+            value = (rand() % (2 * len)) + 1;
         }
+        while (existsInTree(root, value));
+
+        // Baum wie highscore benutzen (immer NULL)
+        root = addToTree(
+            root,
+            &value,
+            sizeof(unsigned int),
+            compareUInt,
+            NULL
+        );
+
+        numbers[i] = value;
     }
 
-    //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 +103,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;
diff --git a/numbers.o b/numbers.o
index bd2248e..61da6c8 100644
Binary files a/numbers.o and b/numbers.o differ
diff --git a/test_numbers.c b/test_numbers.c
index 14ff926..68db631 100644
--- a/test_numbers.c
+++ b/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
-    
-    // Prüfen: Länge stimmt
-    
-    // Prüfen: Array enthält GENAU EIN Duplikat
-    int dupCount = countDuplicates(arr, len);
-    TEST_ASSERT_EQUAL_INT(1, dupCount);
+    // Array muss existieren
+    TEST_ASSERT_NOT_NULL(numbers);
 
-    free(arr);
+    // Es muss genau EIN Duplikat geben
+    unsigned int duplicate = getDuplicate(numbers, len);
+    TEST_ASSERT_NOT_EQUAL(0, duplicate);
+
+    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));
