Fehler bei nichtreservierung von Speicher, stack.c kommentiert

bintree.c

@@ -70,11 +70,14 @@ void *nextTreeData(TreeNode *root) {
 
     TreeNode *curr = root;
     while (curr != NULL) {
-      stack = push(stack, curr);
+      StackNode *oldStack = stack;
+      StackNode *newStack = push(stack, curr);
+      if (newStack == oldStack)
+        return NULL; // push fehlgeschlagen
+      stack = newStack;
       curr = curr->left;
     }
   }
-
   if (stack == NULL)
     return NULL; // alles durchlaufen
 
@@ -85,10 +88,13 @@ void *nextTreeData(TreeNode *root) {
   // Rechten Teilbaum pushen
   TreeNode *curr = node->right;
   while (curr != NULL) {
-    stack = push(stack, curr);
+    StackNode *oldStack = stack;
+    StackNode *newStack = push(stack, curr);
+    if (newStack == oldStack)
+      return NULL; // push fehlgeschlagen
+    stack = newStack;
     curr = curr->left;
   }
-
   return node->data;
 }
 

highscores.txt

@@ -1,7 +1,9 @@
+Kristin;7947
 Kristin;6962
 Kristin;5975
 krisp;4986
 krisp;4985
 Kristin;4972
 player1;3999
+Kristin;3992
 krisp;3991

stack.c

@@ -6,6 +6,7 @@
 
   void *data;
   struct StackNode *next;
+  struct StackNode *prev;
 
 } StackNode;*/
 
@@ -16,12 +17,13 @@
  * `clearStack`: gibt den gesamten Speicher frei. */
 
 // [A] -> [B] -> [C] -> NULL
-// head -> stack.next
+// stack -> stack.next
 
+// Funktion zum erstellen neuer nodes
 StackNode *createNode(void *data) {
-
+  // Speicher reservieren
   StackNode *node = malloc(sizeof(StackNode));
-
+  // Speicher konnte nicht reserviert werden
   if (node == NULL)
     return NULL;
 
@@ -37,46 +39,57 @@ StackNode *push(StackNode *stack, void *data) {
 
   StackNode *newNode = createNode(data);
 
+  // Fehler beim Reservieren des Speichers, stack wird unverändert zurückgegeben
   if (newNode == NULL) {
     return stack;
   }
 
+  // der aktuelle Kopf wird der nächste Node
   newNode->next = stack;
+
+  // bisheriger Kopf bekommt Pointer auf oberstes Element
   if (stack != NULL) {
     stack->prev = newNode;
   }
 
-  return newNode;
+  return newNode; // neuer Kopf wird zurückgegeben
 }
 
 // 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) {
 
+  // Stack ohne Elemente
   if (stack == NULL)
     return NULL;
 
+  // Element unter Kopf wird als nextNode gespeichert
   StackNode *nextNode = stack->next;
   if (nextNode != NULL) {
-    nextNode->prev = NULL;
+    nextNode->prev = NULL; // der Zeiger zum Kopf wird auf NULL gesetzt
   }
 
   free(stack);
 
-  stack = NULL;
+  stack = NULL; // Speicher des Kopfes freigeben
 
-  return nextNode;
+  return nextNode; // neuen Kopf zurückgeben
 }
 
 // Returns the data of the top element.
-void *top(StackNode *stack) { return stack ? stack->data : NULL; }
+void *top(StackNode *stack) {
+  // wenn stack leer ist, wird NULL zurückgegeben
+  // Zeiger auf Daten des obersten Elements
+  return stack ? stack->data : NULL;
+}
 
 // Clears stack and releases all memory.
-void clearStack(StackNode **stack) {
+void clearStack(StackNode **stack) { // Zeiger auf den Zeiger auf den Stackkopf
-
+  // verändert den Zeiger selbst, mit *stack lokale Kopie
+  // im Aufruf &stack verwenden
   while (*stack != NULL) {
-    StackNode *next = (*stack)->next;
+    StackNode *next = (*stack)->next; // nächstes Element speichern
-    free(*stack);
+    free(*stack);                     // aktuelles Element freigeben
-    *stack = next;
+    *stack = next;                    // Zeiger auf nächsten Knoten setzen
   }
 }