bintree.c

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

highscores.txt

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

stack.c

@@ -6,7 +6,6 @@
 
   void *data;
   struct StackNode *next;
-  struct StackNode *prev;
 
 } StackNode;*/
 
@@ -17,13 +16,12 @@
  * `clearStack`: gibt den gesamten Speicher frei. */
 
 // [A] -> [B] -> [C] -> NULL
-// stack -> stack.next
+// head -> 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;
 
@@ -39,57 +37,46 @@ 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; // neuer Kopf wird zurückgegeben
+  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) {
 
-  // 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; // der Zeiger zum Kopf wird auf NULL gesetzt
+    nextNode->prev = NULL;
   }
 
   free(stack);
 
-  stack = NULL; // Speicher des Kopfes freigeben
+  stack = NULL;
 
-  return nextNode; // neuen Kopf zurückgeben
+  return nextNode;
 }
 
 // Returns the data of the top element.
-void *top(StackNode *stack) {
+void *top(StackNode *stack) { return stack ? stack->data : NULL; }
-  // 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) { // Zeiger auf den Zeiger auf den Stackkopf
+void clearStack(StackNode **stack) {
-  // verändert den Zeiger selbst, mit *stack lokale Kopie
+
-  // im Aufruf &stack verwenden
   while (*stack != NULL) {
-    StackNode *next = (*stack)->next; // nächstes Element speichern
+    StackNode *next = (*stack)->next;
-    free(*stack);                     // aktuelles Element freigeben
+    free(*stack);
-    *stack = next;                    // Zeiger auf nächsten Knoten setzen
+    *stack = next;
   }
 }

test_stack.c

@@ -5,62 +5,31 @@
 
 #include "stack.h"
 
-// StackNode *createNode(void *data) testen
 void test_createNode(void) {
 
   int testInt = 26;
-  StackNode *testNode = createNode(&testInt); // Adresse des testInts
+  StackNode *testNode = createNode(&testInt);
 
-  TEST_ASSERT_NOT_NULL(
+  TEST_ASSERT_NOT_NULL(testNode);
-      testNode); // Speicher konnte reserviert werden, malloc ist nicht NULL
+  TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data);
-  TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data); // data pointer gesetzt
+  TEST_ASSERT_NULL(testNode->next);
-  TEST_ASSERT_NULL(testNode->next); // vorheriger und nächster Eintrag NULL
   TEST_ASSERT_NULL(testNode->prev);
 
-  free(testNode); // Speicher freigeben
+  free(testNode);
 }
 
-// StackNode *push(StackNode *stack, void *data) testen
 void test_pushDataToStack(void) {
 
-  int testInts[] = {27, 28};
+  int testInt = 27;
 
-  StackNode *testStack = NULL; // leeren testStack initialisieren
+  StackNode *testNode = push(NULL, &testInt);
 
-  testStack =
+  TEST_ASSERT_NOT_NULL(testNode);
-      push(testStack, &testInts[0]); // leerer Stack mit Adresse des testInts
+  TEST_ASSERT_EQUAL_PTR(&testInt, testNode->data);
+  TEST_ASSERT_NULL(testNode->next);
+  TEST_ASSERT_NULL(testNode->prev);
 
-  TEST_ASSERT_NOT_NULL(testStack); // im Fehlerfall wird testStack unverändert
+  free(testNode);
-                                   // zurückgegeben -> bei Fehler NULL
-  TEST_ASSERT_EQUAL_PTR(&testInts[0], testStack->data); // data pointer gesetzt
-  TEST_ASSERT_NULL(testStack->next); // vorheriger und nächster pointer auf NULL
-                                     // gesetzt, da es nur einen Knoten gibt
-  TEST_ASSERT_NULL(testStack->prev);
-
-  // zweiter Push
-  StackNode *oldHead = testStack;
-
-  testStack = push(testStack, &testInts[1]);
-
-  TEST_ASSERT_NOT_NULL(testStack);
-  TEST_ASSERT_NOT_EQUAL(
-      oldHead,
-      testStack); // bei malloc Fehler wird der head unverändert zurückgegeben
-
-  TEST_ASSERT_EQUAL_PTR(&testInts[0],
-                        oldHead->data); // data pointer wurden richtig gesetzt
-  TEST_ASSERT_EQUAL_PTR(&testInts[1], testStack->data);
-
-  TEST_ASSERT_EQUAL_PTR(oldHead, testStack->next);
-  TEST_ASSERT_EQUAL_PTR(testStack, oldHead->prev);
-  TEST_ASSERT_NULL(testStack->prev);
-
-  // Speicherfreigabe
-  testStack->next = NULL;
-  oldHead->prev = NULL;
-
-  free(oldHead);
-  free(testStack);
 }
 
 void test_deleteTopElement(void) {