Fertig

highscores.txt

@@ -1,3 +1,5 @@
 Silvana;9944
 hannes;9910
+silvana;9865
+player2;4983
 player1;3999

makefile

@@ -1,62 +1,62 @@
 CC = gcc
-FLAGS = -g -Wall -I$(unityfolder)
 
 
-ifeq ($(OS),Windows_NT)
-    include makefile_windows.variables
-else
-    UNAME = $(shell uname)
-    ifeq ($(UNAME),Linux)
-        include makefile_linux.variables
-    else
-        include makefile_mac.variables
-    endif
-endif
-
 raylibfolder = ./raylib
 unityfolder = ./unity
 
-# --------------------------
-# Initiales Programm
-# --------------------------
-doble_initial:
-	$(CC) -o doble_initial $(BINARIES)/libdoble_complete.a
+
+FLAGS = -g -Wall -I$(unityfolder)
+
+
+ifeq ($(OS),Windows_NT)
+include makefile_windows.variables
+else
+UNAME := $(shell uname)
+ifeq ($(UNAME),Linux)
+include makefile_linux.variables
+else
+include makefile_mac.variables
+endif
+endif
 
 # --------------------------
 # Objektdateien
 # --------------------------
-program_obj_files = stack.o bintree.o numbers.o timer.o highscore.o
+program_obj_files := stack.o bintree.o numbers.o timer.o highscore.o
+
 
-# Generische Regel für alle .o-Dateien
 %.o: %.c
 	$(CC) $(FLAGS) -c $< -o $@
 
-# --------------------------
-# Hauptprogramm
-# --------------------------
+
 doble: main.o $(program_obj_files)
 	$(CC) $(FLAGS) $^ -o doble
 
+
+doble_initial:
+	$(CC) -o doble_initial $(BINARIES)/libdoble_complete.a
+
 # --------------------------
 # Unit Tests
 # --------------------------
+
 unitTests:
 	@echo "needs to be implemented"
 
-# Bintree Tests
-binTreeTests: stack.o bintree.o binTreeTests.c $(unityfolder)/unity.c
-	$(CC) $(FLAGS) -o runbintreeTests binTreeTests.c bintree.o stack.o $(unityfolder)/unity.c
 
-# Numbers Tests
+binTreeTest: stack.o bintree.o binTreeTest.c $(unityfolder)/unity.c
+	$(CC) $(FLAGS) -o runbinTreeTest binTreeTest.c bintree.o stack.o $(unityfolder)/unity.c
+
+
 test_numbers: numbers_no_tree.o bintree.o stack.o test_numbers.c $(unityfolder)/unity.c
 	$(CC) $(FLAGS) -o run_numbersTests test_numbers.c numbers_no_tree.o bintree.o stack.o $(unityfolder)/unity.c
 
-# Stack Tests
+
 test_stack: stack.o test_stack.c $(unityfolder)/unity.c
 	$(CC) $(FLAGS) -o runstackTests test_stack.c stack.o $(unityfolder)/unity.c
 
 # --------------------------
-# Clean
+# Cleaning
 # --------------------------
 clean:
 ifeq ($(OS),Windows_NT)

numbers.c

@@ -17,85 +17,88 @@
 // Returns len random numbers between 1 and 2*len in random order,
 // all different, except for exactly one duplicate (two entries the same).
 // Uses your binary search tree implementation to check for duplicates while generating numbers.
-unsigned int *createNumbers(unsigned int len)
-{
-  if (len < 2)
-    return NULL;
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include "numbers.h"
+#include "bintree.h"
 
-  srand(time(NULL));
-
-
-  unsigned int *numbers = malloc(len * sizeof(unsigned int));
-  if (!numbers)
-    return NULL;
-
-  TreeNode *root = NULL; // Baum anfänglich leer
-  unsigned int count = 0;
-
-  // Zufallszahlen generieren, bis das Array voll ist
-  while (count < len) {
-    unsigned int random = (rand() % (2 * len)) + 1;
-
-    int duplicate = 0; // Anfangswert für Duplikat-Check
-    root = addToTree(root, &random, sizeof(random), compareFct, &duplicate);
-
-    if (root == NULL) {
-      free(numbers);
-      return NULL;
-    }
-
-    if (!duplicate) { // Zahl war neu → ins Array einfügen
-      numbers[count++] = random;
-    }
-    // duplicate == 1 → Zahl existiert schon, neue Zahl generieren
+int compareFct(const void *a, const void *b)
+  {
+      return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)b); // a und b werden in int konvertiert und deren Werte miteinander verglichen
+                                                                // returns 1 for a>b or -1 for a<b
+                                                                // in bintree.c wird ueberprueft, ob compare eine positive oder eine negative Zahl zurueckgibt,
+                                                                // wenn a groeßer b, positiv und dann wird links nach Teilbauemen gesucht
   }
 
-  // Jetzt len eindeutige Zahlen erzeugt → ein Duplikat erzwingen
-  unsigned int idx1 = rand() % len;
-  unsigned int idx2 = rand() % len;
-  while (idx2 == idx1)                // sicherstellen, dass es eine andere Position ist
-    idx2 = rand() % len;
+// Erzeugt len Zufallszahlen zwischen 1 und 2*len
+// alle einzigartig, außer genau ein Duplikat
+unsigned int *createNumbers(unsigned int len)
+{
+    if (len < 2)
+        return NULL;
 
-  numbers[idx2] = numbers[idx1];
+    srand((unsigned int)time(NULL));
 
-  // Baum wieder freigeben
-  clearTree(root);
+    unsigned int *numbers = malloc(len * sizeof(unsigned int));
+    if (!numbers)
+        return NULL;
 
-  return numbers;
-}
+    TreeNode *root = NULL; // Baum anfänglich leer
+    unsigned int count = 0;
 
-  // Jetzt len eindeutige Zahlen erzeugt ⇒ wir müssen ein Duplikat erzwingen
-  unsigned int idx1 = rand() % len;
-  unsigned int idx2 = rand() % len;
-  while (idx2 == idx1)
-    idx2 = rand() % len;
+    // Zufallszahlen generieren, bis das Array voll ist
+    while (count < len)
+    {
+        unsigned int random = (rand() % (2 * len)) + 1;
+        int duplicate = 0; // Anfangswert für Duplikat-Check
 
-  numbers[idx2] = numbers[idx1];   // zweites Exemplar
+        root = addToTree(root, &random, sizeof(random), compareFct, &duplicate);
 
-  clearTree(root);
-  return numbers;
+        if (root == NULL)
+        {
+            free(numbers);
+            return NULL;
+        }
+
+        if (!duplicate)
+        {
+            numbers[count++] = random;
+        }
+        // duplicate == 1 → Zahl existiert schon, neue Zahl generieren
+    }
+
+    // genau ein Duplikat erzeugen
+    unsigned int idx1 = rand() % len;
+    unsigned int idx2 = rand() % len;
+    while (idx2 == idx1)
+        idx2 = rand() % len;
+
+    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.
+// findet die eine doppelte Zahl im Array
 unsigned int getDuplicate(const unsigned int numbers[], unsigned int len)
 {
-  if(len>0)
+    if (!numbers || len < 2)
+        return 0;
+
+    for (unsigned int i = 0; i < len; i++)
     {
-    unsigned int duplicate = 0;
-    for(unsigned int i=0;i<len;i++)
-      {
-        unsigned int v1 = numbers[i];
-        for(unsigned int j=i+1;j<len;j++)
-          {
-          unsigned int v2 = numbers[j];
-          if(v1==v2)
-            {
-            return v1;
-            }
-          }
-      }
+        for (unsigned int j = i + 1; j < len; j++)
+        {
+            if (numbers[i] == numbers[j])
+                return numbers[i];
+        }
     }
-  return 0;
+
+    return 0;
 }
 
+

numbers.h

@@ -1,6 +1,8 @@
 #ifndef NUMBERS_H
 #define NUMBERS_H
 
+
+int compareFct(const void *a, const void *b);
 // 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.

test_stack.c

@@ -4,6 +4,14 @@
 
 //Testfunkionen zu push, pull, top & clearStack schreiben
 
+void setUp()
+  {
+  }
+
+void tearDown()
+      {
+  }
+
 void test(char *name, int condition) {
     if (condition) {
         printf("[OK]   %s\n", name);