Merge branch 'jonas' of https://git.efi.th-nuernberg.de/gitea/gloecknerni100842/I2_Projects into jonas

.gitignore

@@ -5,4 +5,5 @@
 !**/*.c
 !**/*.h
 !**/*Makefile
-!**/*.md
+!**/*.md
+I2_Dobble/highscores.txt

I2_Dobble/bintree.c

@@ -60,7 +60,6 @@ TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFc
 // push the top node and push all its left nodes.
 void *nextTreeData(TreeNode *root)
 {
-    // Neues Traversieren?
     if (root != NULL)
     {
         clearStack(iteratorStack);
@@ -75,7 +74,7 @@ void *nextTreeData(TreeNode *root)
         }
     }
 
-    // Wenn Stack leer → fertig
+    // Wenn Stack leer -> fertig
     if (iteratorStack == NULL)
         return NULL;
 

I2_Dobble/bintree.md

@@ -0,0 +1,100 @@
+1) static StackNode *iteratorStack = NULL
+    -> Stack für nextTreeData
+    -> wird verwendet um nach und nach die Zahlen von klein nach groß auszugeben
+    -> muss da so stehen, weil ansonsten nextTreeData immer von vorne anfängt
+
+2) addToTree -> soll ein Element an die richtige Stelle im Baum hinzufügen
+    -> wenn keine root angegeben ist (wenn entweder kein Baum vorhanden ist, oder die richtige Stelle gefunden wurde) soll ein neue Node erstellt werden.
+        -> Speicher reservieren
+        -> data nach newNode.data kopieren (memcpy) kopiert einfach nur den Inhalt ohne ihn zu interpretieren
+        -> pointer links und rechts werden NULL gesetzt, da keine anderen Datan vorhanden sind
+        -> isDublicate = 0, da kein Dublikat vorhanden sein kann
+    
+    -> root.data wird mit data verglichen (größer, kleiner, gleich), um zu entscheiden, ob rechts oder links eingefügt werden soll
+        -> gleich -> Dublikat -> einfügen verhindern
+        -> größer -> rechts einfügen
+        -> kleiner -> links einfügen
+
+    -> eingefügt wird, in dem addToTree erneut aufgerufen wird, aber jetzt als root root.left/root.right übergeben wird
+    -> es wird erneut verglichen und wieder in den rechten, bzw. linken Teilbaum eingefügt, solange bis richtige Stelle im Baum erreicht ist -> einfügen des Wertes
+
+3) nextTreeData 
+    -> soll nacheinander die Werte des Binärbaums der größe nach ausgeben
+    -> Diese Funktion beruht auf einem richtigen Binär Baum (werte stehen an der richtigen Stelle)
+    -> dabei wird der iteratorStack verwendet, auf diesem sind immer Teilbereiche unseres Binärbaums vorhanden (in sortierter Reihenfolge), allerdings ist er nie vollständig, sondern wird im laufe des Programms immer durch fehlende Werte ergänzt
+    
+    -> wenn root != NULL -> neuer Beginn bei einem ggf. anderen Baum
+        -> iteratorStack wird gelöscht um eventuelle "Rückstände" zu beseitigen
+        -> danach werden erstmal immer die jeweils linken Nodes in den Stack gepusht
+            -> im Stack liegt nun die kleinste Node ganz oben, danach werden die Werte immer größer, allerdings fehlen noch Werte dazwischen
+    
+    -> anschließend wird sich die oberste Node aus dem Stack geholt und aus dem Stack entfernt -> Die ist der kleinste Wert im Baum und soll somit auch als erste zurückgegeben werden
+    -> jetzt wird auf dem Stack der rechte Teilbaum von unseren kleinsten Wert im Baum auf den Stack gepusht -> diese Werte sind alle größer als unsere Node, jedoch kleiner als die davor vorletzte Node im Stack -> DER STACK IST ALSO IMMER NOCH NACH DER GRÖßE SORTIERT
+    -> unser Stack hat jetzt den nächst größeren Wert im Baum als top Node -> ausgangssituation für nächsten Aufruf
+    -> gepeicherte node wird verwendet um node.data auszugeben
+
+
+
+                    Beispiel Baum:
+
+                                12
+                               /  \
+                              8    15
+                            /  \     \
+                           5    9     17
+                                    /   \
+                                   16   20
+
+                    1) erst alle linken Nodes pushen -> 5
+                                                        8
+                                                        12
+                    
+                    2) top Node (5) speichern und aus Stack entfernen -> 8 
+                                                                         12
+
+                    3) rechte Node und alle jeweils linken Nodes pushen -> 8
+                                                                           12
+                    4) -> 5 wird ausgegeben (gepeicherte Node)
+                    5) neuer Aufruf
+                        6) top Node speichern (8) und aus Stack entfernen -> 12
+                        7) rechte Node und alle jeweils linken Nodes pushen -> 9
+                                                                               12
+                        8) -> 8 wird ausgegeben (gespeicherte Node)
+                    9) neuer Aufruf
+                        10) top Node speichern (9) und aus Stack entfernen -> 12
+                        11) rechte Node und alle jeweils linken Nodes pushen -> 12
+                        12) ->  9 wird ausgegeben (gespeicherte Node)
+                    13) neuer Aufruf
+                        14) top Node speichern (12) und aus Stack entfernen -> NULL
+                        15) rechte Node und alle jeweils linken Nodes pushen -> 15
+                        16) -> 12 wird ausgegeben (gespeicherte Node)
+                    17) neuer Aufruf
+                        18) top Node speichern (15) und aus Stack entfernen -> NULL
+                        19) rechte Node und alle jeweils linken Nodes pushen -> 16
+                                                                                17
+                        20) -> 15 wird ausgegeben (gespeicherte Node)
+                    21) neuer Aufruf
+                        22) top Node speichern (16) und aus Stack entfernen -> 17
+                        23) rechte Node und alle jeweils linken Nodes pushen -> 17
+                        24) -> 16 wird ausgegeben (gespeicherte Node)
+                    25) neuer Aufruf
+                        26) top Node speichern (17) und aus Stack entfernen -> NULL
+                        27) rechte Node und alle jeweils linken Nodes pushen -> 20
+                        28) -> 17 wird ausgegeben (gespeicherte Node)
+                    29) neuer Aufruf
+                        30) top Node speichern (20) und aus Stack entfernen -> NULL
+                        31) rechte Node und alle jeweils linken Nodes pushen -> NULL
+                        32) -> 20 wird ausgegeben (gespeicherte Node)
+                    33) neuer Aufruf -> Stack = NULL -> fertig
+                                                                                                                
+                                                                                                            
+4) treeSize
+    -> rekursiver Aufruf der Funktion
+
+    -> es wird jeweils die jeweils linke und rechte Node als neue root genommen
+    -> aufruf mit treeSize(root->left / root -> right)
+    -> es wird pro aufruf +1 gerechnet
+    -> am Ende wird die Node Anzahl zurückgegeben
+
+
+

I2_Dobble/makefile

@@ -1,6 +1,5 @@
 CC = gcc
 CFLAGS = -g -Wall
-LDFLAGS = -lm
 
 ifeq ($(OS),Windows_NT)
 	include makefile_windows.variables

I2_Dobble/number.md

@@ -1,4 +1,4 @@
-*createNumbers: 
+*createNumbers: -> numbers array gets filled with random entry with only one dublicate
 
 -> check if len is greater than 2
 -> create new array numbers, use malloc and check if correct
@@ -7,7 +7,10 @@
 -> add new value to tree using addToTree and rand()
 -> addToTree sets isDup to 1, if value already exists
 -> if value does not already exist -> add to numbers[]
--> 
+-> stops at numbers[len -2]
+static dublicateRandomEntry:
+-> numbers[len-1] is filled with random already existing number
+-> numbers[len -1] gets switched with other random entry -> dublicate is placed randwom in entry; without the switch, dublicate would always be at the end
 
 
 getDublicate:
@@ -15,7 +18,7 @@ getDublicate:
 -> numbers (Zeiger != NULL) und len (min. 2) check
 -> define new array numbersCopy
 -> copy numbers to numbersCopy 
-    -> simple loop to copy each element number -> numbersCopy
+    -> simple loop to copy each element from numbers to numbersCopy
 -> sort numbersCopy with qsort
 -> compare each element of numbersCopy with next element (if numbersCopy[i] == numbersCopy[i+1] -> dublicate was found, because same values are right next to each other)
 -> return found dublicate

I2_Dobble/numbers.c

@@ -11,14 +11,33 @@
   * 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.
-// Returns NULL on errors. Use your implementation of the binary search tree to check for possible duplicates while
-// creating random numbers.
+static void dublicateRandomEntry (unsigned int *numbers, unsigned int len)
+{
+   if (numbers && len > 2)
+   {
+        unsigned int dubIndx = rand() % (len - 1);
+        unsigned int copyIndx;
+        
+        copyIndx = rand() % len;
+
+        numbers[len - 1] = numbers[dubIndx];
+
+        //switching last entry with random other entry
+        unsigned int temp;
+        temp = numbers[copyIndx];
+        numbers[copyIndx] = numbers[len - 1];
+        numbers[len - 1] = temp;
+    }
+}
+
 static int compare(const void *a, const void *b) 
 {
     return (*(int *)a > *(int *)b) - (*(int *)a < *(int *)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
 unsigned int *createNumbers(unsigned int len)
 {
     if (len < 2) 
@@ -48,8 +67,7 @@ unsigned int *createNumbers(unsigned int len)
     }
 
     // Duplicate one random entry
-    unsigned int dupIndex = rand() % (len - 1);
-    numbers[len - 1] = numbers[dupIndex];
+    dublicateRandomEntry(numbers, len);
 
     clearTree(root); //Notwendigkeit muss noch restlichem Code entnommen werden
     return numbers;

I2_Dobble/stack.c

@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include "stack.h"
 
-//TODO: grundlegende Stackfunktionen implementieren:
+//DONE: grundlegende Stackfunktionen implementieren:
 /*  * `push`: legt ein Element oben auf den Stack,
     * `pop`: entfernt das oberste Element,
     * `top`: liefert das oberste Element zurück,
@@ -10,47 +10,52 @@
 // Pushes data as pointer onto the stack.
 StackNode *push(StackNode *stack, void *data)
 {
-    StackNode *newNode = malloc(sizeof(StackNode));
-    if (!newNode)
-        return stack;
+    //        ,-→ Wenn keine Daten angegeben wird die Liste unverändert zurückgegeben
+    if (data != NULL)
+    {
+        StackNode *newNode;
+        newNode = (StackNode *)malloc(sizeof(StackNode));
+        newNode->data = data;
+        
+        //         ,-→ bedeutet Liste war leer - das neue Element hat keinen Nachfolger (next = NULL)
+        if (stack == NULL) {
+            newNode->next = NULL;
+        } else {
+            newNode->next = stack;
+        }
+        stack = newNode;
+    }
     
-    newNode->data = data;
-    newNode->next = stack;
-
-    return newNode;
+    return stack;
 }
 
-// Deletes the top element of the stack (latest added element) and releases its memory. (Pointer to data has to be
-// freed by caller.)
+// 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 *newTopElement = stack->next;
-    free(stack);
-
-    return newTopElement;
+    if(stack != NULL)
+    {
+        StackNode *nextNode = stack->next;
+        free(stack);
+        stack = nextNode;
+    }
+    return stack;
 }
 
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
-    if (!stack)
+    if (stack != NULL) {
+        return stack->data;
+    } else {
         return NULL;
-
-    return stack->data;
+    } 
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode *stack)
 {
-    StackNode *current = stack;
-
-    while (current)
-    {
-        StackNode *next = current->next;
-        free(current);
-        current = next;
+    while (stack != NULL) {
+        stack = pop(stack);
     }
-}
+}

I2_Dobble/stack.h

@@ -7,11 +7,11 @@ The latest element is taken from the stack. */
 
 #include <stdlib.h>
 
-//TODO: passenden Datentyp als struct anlegen
-typedef struct stack
+//DONE: passenden Datentyp als struct anlegen
+typedef struct Node
 {
-    void *data;
-    struct stack *next;
+  void *data;
+  struct Node* next;
 } StackNode;
 
 // Pushes data as pointer onto the stack.

I2_Dobble/stackTest.c

@@ -1,9 +1,148 @@
 #include "stack.h"
-#include "unity.h"
-#include "unity_internals.h"
+#include "unity/unity.h"
+#include "unity/unity_internals.h"
 
-void setUp(void) { }
-void tearDown(void) { }
+/* wird nicht mehr gebraucht
+
+// Ein Blick in den Stack - listet den Stack-Inhalt der Reihe nach auf
+void inspectStack(StackNode *stack)
+{    
+    if (stack != NULL)
+    {
+        printf("Der Stack enthält die folgenden Elemente: %d", *(int*)stack->data);
+        while (stack->next != NULL)
+        {
+            printf(" %d", *(int*)stack->next->data);
+            stack = stack->next;
+        }
+        putchar('\n');
+    }
+    else
+    {
+        printf("Der Stack ist leer\n");
+    }
+}
+*/
+
+// Setup-Funktionen von Unity, die zumindest als Platzhalter definiert sein müssen
+void setUp(void) {};
+void tearDown(void) {};
+
+void test_createNodeAbortsOnZeroData(void)
+{
+    void *data = NULL;
+    StackNode *stack = NULL;
+    stack = push(stack, data);
+    TEST_ASSERT_EQUAL_PTR(stack, NULL);
+
+    clearStack(stack);
+}
+
+void test_createdNodeIsFirstInList(void)
+{
+    int data = 42;
+    StackNode *stack = NULL;
+    stack = push(stack, &data);
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(&data, stack->data);
+    TEST_ASSERT_NULL(stack->next);
+
+    clearStack(stack);
+}
+
+void test_createNodeCorrectOrder(void)
+{
+    int data[3] = {0, 1, 2};
+    StackNode *stack = NULL;
+    stack = push(stack, &data[2]);
+    stack = push(stack, &data[1]);
+    stack = push(stack, &data[0]);
+
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(&data[0], stack->data);
+    TEST_ASSERT_EQUAL_PTR(&data[1], stack->next->data);
+    TEST_ASSERT_EQUAL_PTR(&data[2], stack->next->next->data);
+    TEST_ASSERT_NULL(stack->next->next->next);
+
+    clearStack(stack);
+}
+
+void test_removeNodeAbortsOnZero(void)
+{
+    StackNode *stack = NULL;
+    TEST_ASSERT_NULL(pop(stack));
+
+    clearStack(stack);
+}
+
+void test_removeOnlyNodeEmptysList(void)
+{
+    int data = 42;
+    StackNode *stack = NULL;
+    stack = pop(push(stack, &data));
+
+    TEST_ASSERT_NULL(stack);
+
+    clearStack(stack);
+}
+
+void test_removeNodeRemovesFirst(void)
+{
+    int data[2] = {0, 1};
+    StackNode *stack = NULL;
+    stack = push(stack, &data[1]);
+    stack = push(stack, &data[0]);
+    stack = pop(stack);
+
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(&data[1], stack->data);
+    TEST_ASSERT_NULL(stack->next);
+
+    clearStack(stack);
+}
+
+void test_outputTopFailsOnZero(void)
+{
+    StackNode *stack = NULL;
+    
+    TEST_ASSERT_NULL(top(stack));
+
+    clearStack(stack);
+}
+
+void test_outputTopCorrect(void)
+{
+    int data[2] = {0, 1};
+    StackNode *stack = NULL;
+    stack = push(stack, &data[1]);
+    stack = push(stack, &data[0]);
+
+    TEST_ASSERT_NOT_NULL(stack);
+    TEST_ASSERT_EQUAL_PTR(top(stack), stack->data);
+
+    clearStack(stack);
+}
+
+
+/* Speicher freigabe lässt sich nicht mit Unity testen, am besten Programm mit valgrind ausführen
+void test_clearStackFreesMemory(void)
+{
+    int data[2] = {22, 17};
+    StackNode *lowNode = (StackNode *)malloc(sizeof(StackNode));
+    lowNode->next = NULL;
+    lowNode->data = &data[0];
+    StackNode *highNode = (StackNode *)malloc(sizeof(StackNode));
+    highNode->next = lowNode;
+    highNode->data = &data[1];
+    StackNode *stack = highNode;
+
+    clearStack(stack);
+
+    TEST_ASSERT_NULL(lowNode);
+    TEST_ASSERT_NULL(highNode);
+    TEST_ASSERT_NULL(stack);
+}
+*/
 
 void test_push_should_add_new_node_at_top(void)
 {
@@ -94,6 +233,29 @@ int main()
 {
     UNITY_BEGIN();
 
+<<<<<<< HEAD
+<<<<<<< HEAD
+<<<<<<< HEAD
+    printf("\n============================\n Stack tests\n============================\n");
+    printf("-> Create Nodes (push)\n");
+    RUN_TEST(test_createNodeAbortsOnZeroData);
+    RUN_TEST(test_createdNodeIsFirstInList);
+    RUN_TEST(test_createNodeCorrectOrder);
+
+    printf("\n-> Remove Nodes (pop)\n");
+    RUN_TEST(test_removeNodeAbortsOnZero);
+    RUN_TEST(test_removeOnlyNodeEmptysList);
+    RUN_TEST(test_removeNodeRemovesFirst);
+
+    printf("\n-> Output Top (top)\n");
+    RUN_TEST(test_outputTopFailsOnZero);
+    RUN_TEST(test_outputTopCorrect);
+
+=======
+>>>>>>> 0c075ea (stackTest file added)
+=======
+=======
+>>>>>>> ef8340ba6b9e7a4d6bac8d0eb9b4b987a9316088
     RUN_TEST(test_push_should_add_new_node_at_top);
     RUN_TEST(test_push_multiple_should_chain_nodes_correctly);
     RUN_TEST(test_top_should_return_null_on_empty_stack);
@@ -102,5 +264,9 @@ int main()
     RUN_TEST(test_pop_should_remove_single_element);
     RUN_TEST(test_pop_should_remove_top_node_only);
 
+<<<<<<< HEAD
+>>>>>>> 0d561c0 (added stackTest)
+=======
+>>>>>>> ef8340ba6b9e7a4d6bac8d0eb9b4b987a9316088
     return UNITY_END();
 }

I2_Dobble/test_stack.c

@@ -0,0 +1,80 @@
+#include <bits/types/stack_t.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "stack.h"
+
+void inspectStack(StackNode *stack)
+{    
+    if (stack != NULL)
+    {
+        printf("Der Stack enthält die folgenden Elemente: %d", *(int*)stack->value);
+        while (stack->next != NULL)
+        {
+            printf(" %d", *(int*)stack->next->value);
+            stack = stack->next;
+        }
+        putchar('\n');
+    }
+    else
+    {
+        printf("Der Stack ist leer\n");
+    }
+}
+
+int main()
+{
+    StackNode *stack;
+    stack = NULL; // initialisierung mit NULL -> leere Liste
+    
+    printf("...ein Element wird eingefügt...\n");
+    int toBeRemoved = 42;
+    stack = push(stack, &toBeRemoved);
+    
+    inspectStack(stack);
+
+    printf("...das Element wird wieder entfernt...\n");
+    stack = pop(stack);
+    
+    inspectStack(stack);
+    
+    printf("...pop auf leeren Stack...\n");
+    stack = pop(stack);
+    
+    inspectStack(stack);
+    putchar('\n');
+
+    int data[5] = {1, 2, 3, 4, 5};
+
+    // alle 5 werte der reihe nach auf den Satck legen - 1 unten ... 5 oben
+    for (int i = 0; i < 5; i++)
+    {
+        stack = push(stack, &data[i]);
+    }
+
+    
+    //alle Elemente mit Test-Funktion ausgeben
+    inspectStack(stack);
+    
+    // Elemente stück für Stück ausgeben und entfernen
+    printf("1. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("2. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("3. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("4. Element war: %d\n", *(int*)top(stack));
+    stack = pop(stack);
+    printf("5. Element war: %d\n", *(int*)top(stack));
+}
+
+/*
+int main()
+{
+    UNITY_BEGIN();
+
+    printf("============================\n Stack tests\n============================\n");
+    RUN_TEST(test_createNodeFailsOnZeroData);
+
+    return UNITY_END();
+}
+*/