albarjasmo87623/A3_DobleSpiel
1
0
Fork 0
generated from freudenreichan/info2Praktikum-DobleSpiel
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement stack functions

Browse Source
This commit is contained in:
Albarjas 2026-05-21 16:45:18 +02:00
parent 981a8998eb
commit f7fa0bf67e
2 changed files with 50 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
stack.c
View File

@ -1,33 +1,60 @@
#include <stdlib.h>
#include "stack.h"
//TODO: grundlegende Stackfunktionen implementieren:
/* * `push`: legt ein Element oben auf den Stack,
* `pop`: entfernt das oberste Element,
* `top`: liefert das oberste Element zurück,
* `clearStack`: gibt den gesamten Speicher frei. */
// Pushes data as pointer onto the stack.
StackNode *push(StackNode *stack, void *data)
{
StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));
if (newNode == NULL)
{
return stack;
}
newNode->data = data;
newNode->next = stack;
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.)
// 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)
{
StackNode *nextNode = NULL;
if (stack != NULL)
{
nextNode = stack->next;
free(stack);
}
return nextNode;
}
// Returns the data of the top element.
void *top(StackNode *stack)
{
void *data = NULL;
if (stack != NULL)
{
data = stack->data;
}
return data;
}
// Clears stack and releases all memory.
void clearStack(StackNode *stack)
{
StackNode *currentNode = stack;
StackNode *nextNode = NULL;
while (currentNode != NULL)
{
nextNode = currentNode->next;
free(currentNode);
currentNode = nextNode;
}
}

21
stack.h
View File

@ -1,19 +1,28 @@
#ifndef STACK_H
#define STACK_H
/* A stack is a special type of queue which uses the LIFO (last in, first out) principle.
This means that with each new element all other elements are pushed deeper into the stack.
/* A stack is a special type of queue which uses the LIFO (last in, first out) principle.
This means that with each new element all other elements are pushed deeper into the stack.
The latest element is taken from the stack. */
#include <stdlib.h>
//TODO: passenden Datentyp als struct anlegen
/*
* One node of the stack.
* data stores a generic pointer.
* next points to the next element below this one.
*/
typedef struct StackNode
{
void *data;
struct StackNode *next;
} StackNode;
// Pushes data as pointer onto the stack.
StackNode *push(StackNode *stack, void *data);
// 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);
// Returns the data of the top element.
@ -22,4 +31,4 @@ void *top(StackNode *stack);
// Clears stack and releases all memory.
void clearStack(StackNode *stack);
#endif
#endif