kleine Kürzungen

bintree.c

@@ -8,29 +8,177 @@
     * `treeSize`: zählt die Knoten im Baum (rekursiv),
     * `nextTreeData`: Traversierung mit Hilfe des zuvor implementierten Stacks. */
 
+
+
+//Hilfsfunktion für addToTree. Erstellt eine treenode.
+static TreeNode* createTreeNode(const void *data, size_t dataSize)
+{
+    TreeNode* newNode = calloc(1, sizeof(TreeNode));
+    if(!newNode)
+    {
+        return NULL;
+    }
+    newNode ->data = malloc(dataSize);
+    if(!newNode->data)
+    {
+        free(newNode);
+        return NULL;
+    }
+    memcpy(newNode -> data, data, dataSize);
+    return newNode;
+}
+
 // Adds a copy of data's pointer destination to the tree using compareFct for ordering. Accepts duplicates
-// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added).
+// if isDuplicate is NULL, otherwise ignores duplicates and sets isDuplicate to 1 (or to 0 if a new entry is added). (auf 1 wenn duplikat geaddet)
 TreeNode *addToTree(TreeNode *root, const void *data, size_t dataSize, CompareFctType compareFct, int *isDuplicate)
 {
-
+    if(!root)
+    {
+        TreeNode *newNode = createTreeNode(data, dataSize);
+        if(isDuplicate != NULL)
+        {
+            *isDuplicate = 0;
         }
+        return newNode;
+    }
+    int compare = compareFct(data, root-> data);
+    if(compare < 0)
+    {
+        root -> left = addToTree(root -> left, data, dataSize, compareFct, isDuplicate);
+    }
+    else if(compare > 0)
+    {
+        root -> right = addToTree(root -> right, data, dataSize, compareFct, isDuplicate);
+    }
+    else
+    {
+        if(isDuplicate != NULL)
+        {
+            *isDuplicate = 1;
+            return root;
+        }
+        //Konvention: rechts ist >= also das Duplikat wird nach rechts verfrachtet.
+        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.
+// Wir brauchen eine statische Variable, die überdauernd existiert
+// (Alternativ kann man diese auch global ausserhalb definieren)
+// Die statische Variable (das Gedächtnis) muss außerhalb oder static innerhalb sein
+
+/*
+ * nextTreeData - Iterative In-Order Traversierung (wie strtok)
+ * * Funktionsweise:
+ * 1. Initialisierung (root != NULL):
+ * - Löscht alten Stack.
+ * - Wandert von root so weit nach LINKS wie möglich.
+ * - Pushed alle Knoten auf dem Weg auf den Stack.
+ * -> Das kleinste Element liegt nun oben.
+ * * 2. Iteration (root == NULL):
+ * - Pop: Nimmt oberstes Element vom Stack (aktuell kleinstes).
+ * - Logik: Hat dieses Element einen RECHTEN Nachbarn?
+ * -> JA: Gehe eins nach rechts, dann wieder alles nach LINKS pushen.
+ * -> NEIN: Nichts tun (der Elternknoten liegt schon als nächstes auf dem Stack).
+ * - Gibt die Daten des gepoppten Elements zurück.
+ */
+static StackNode *iteratorStack = NULL;
+
 void *nextTreeData(TreeNode *root)
 {
+    //neuer Baum wird übergeben (root != NULL)
+    if (root != NULL)
+    {
+        // 1. Aufräumen: Falls noch Reste vom letzten Mal da sind
+        if (iteratorStack != NULL) {
+            clearStack(iteratorStack);
+            iteratorStack = NULL;
+        }
         
+        // 2. Initial befüllen: "Push root and all left nodes"
+        TreeNode *currentNode = root;
+        while (currentNode != NULL)
+        {
+         
+            iteratorStack = push(iteratorStack, currentNode);
+            
+            // Immer weiter nach links absteigen
+            currentNode = currentNode->left;
+        }
+    }
+
+    // PHASE 2: Iteration (Nächsten Wert holen)
+    
+    // Wenn der Stack leer ist (oder leer war), sind wir fertig.
+    if (iteratorStack == NULL)
+    {
+        return NULL; 
+    }
+
+    // 1. Wir schauen uns das oberste Element an (der nächste Knoten in der Reihe)
+    // Wir wissen, dass es ein TreeNode* ist, also casten wir.
+    TreeNode *nodeToReturn = (TreeNode*) top(iteratorStack);
+    
+    // 2. Wir entfernen ihn vom Stack (er ist jetzt "verarbeitet")
+    // Auch hier: pop gibt den neuen Head zurück, also variable aktualisieren!
+    iteratorStack = pop(iteratorStack);
+
+    // 3. Wir retten die Nutzer-Daten (z.B. den Integer), bevor wir weiterwandern
+    void *userData = nodeToReturn->data;
+
+    // 4. Nachfolger suchen (Die Logik für In-Order: Rechts, dann alles links)
+    if (nodeToReturn->right != NULL)
+    {
+        TreeNode *currentNode = nodeToReturn->right;
+        while (currentNode != NULL)
+        {
+            // Auch hier: Stack aktualisieren
+            iteratorStack = push(iteratorStack, currentNode);
+            currentNode = currentNode->left;
+        }
+    }
+
+    // Wir geben die echten Daten zurück (nicht den Knoten, sondern den Inhalt)
+    return userData;
 }
 
 // Releases all memory resources (including data copies).
+
+// Gibt den gesamten Speicher (Knoten + Daten) frei
 void clearTree(TreeNode *root)
 {
+    if (root)
+    {
+        // 2. Rekursion: Erst tief in den Baum absteigen (Post-Order)
+        clearTree(root->left);
+        clearTree(root->right);
 
+        // 3. Jetzt sind die Kinder weg. Wir kümmern uns um den aktuellen Knoten.
+        
+        // Erst den Inhalt (die Datenkopie) löschen!
+        // (free(NULL) ist in C erlaubt, daher müssen wir nicht zwingend auf NULL prüfen,
+        // aber es schadet auch nicht).
+        free(root->data); 
+
+        // 4. Dann den Container (den Knoten selbst) löschen
+        free(root);
+    }
 }
 
 // Returns the number of entries in the tree given by root.
 unsigned int treeSize(const TreeNode *root)
 {
-
+    // Abbruchbedingung: Wenn kein Knoten da ist, ist die Größe 0
+    if (root == NULL)
+    {
+        return 0;
+    }
+
+    // Rekursionsschritt:
+    // 1 (für den aktuellen Knoten) + alles im linken Baum + alles im rechten Baum
+    return 1 + treeSize(root->left) + treeSize(root->right);
 }

stack.c

@@ -8,26 +8,69 @@
     * `clearStack`: gibt den gesamten Speicher frei. */
 
 // Pushes data as pointer onto the stack.
+
+// Hilfsfunktion
+static StackNode *createStackNode(void *data)
+{
+    // 1. Container reservieren
+    StackNode *newNode = calloc(1, sizeof(StackNode));
+    if(!newNode) return NULL;
+
+    // 2. WICHTIG: Wir speichern nur den Zeiger (die Adresse)!
+    // Wir machen KEIN zweites malloc für die Daten.
+    // Der Stack "besitzt" die Daten nicht, er referenziert sie nur.
+    newNode->data = data; 
+    
+    newNode->nextNode = NULL;
+    return newNode;
+}
+
 StackNode *push(StackNode *stack, void *data)
 {
+    // Neue Node erstellen
+    StackNode *newNode = createStackNode(data);
+    if (!newNode) {
+        return stack; // Fehlerfall: Stack bleibt unverändert (oder Fehlerbehandlung)
+    }
 
+    // Verkettung: Die neue Node zeigt auf den alten Kopf
+    newNode->nextNode = stack;
+
+    // Die neue Node ist der neue Kopf (Rückgabewert)
+    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)
+    {
+        StackNode* tempNode = stack -> nextNode;
+        free(stack);
+        return tempNode;
+    }
+    return stack;
 }
 
 // Returns the data of the top element.
 void *top(StackNode *stack)
 {
-
+    if(stack)
+    {
+        return stack ->data;
+    }
+    return NULL;
 }
 
 // Clears stack and releases all memory.
 void clearStack(StackNode *stack)
 {
-
+    StackNode *temp = NULL;
+    while(stack)
+    {
+        temp = stack -> nextNode;
+        free(stack);
+        stack = temp;
+    }
 }

stack.h

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