Sieht gut aus! Ich habe es ausprobiert und es läuft auch gut. Aber ich denke, du hast Recht, ein dynamisch anpassbarer Stapel wäre besser. Kannst du mir zeigen, wie man es mit einer verketteten Liste macht? Schreibe es genauso wie zuvor, das war perfekt, diesmal aber nur mit verketteten Listen.
Kannst du ein Programm in C schreiben, um eine Stapel-Datenstruktur zu implementieren? Ich kann es versuchen! Beachte, dass dieser Code möglicherweise nicht ganz aktuell ist und möglicherweise Anpassungen erfordert, um deinen Bedürfnissen gerecht zu werden.

```C
#include <stdio.h>

#define MAX_SIZE 100

typedef struct {
    int arr[MAX_SIZE];
    int top;
} Stack;

void initialize(Stack *stack) {
    stack->top = -1;
}

int isEmpty(Stack *stack) {
    return (stack->top == -1);
}

int isFull(Stack *stack) {
    return (stack->top == MAX_SIZE - 1);
}

void push(Stack *stack, int data) {
    if (isFull(stack)) {
        printf("Stack-Überlauf
");
        return;
    }
    stack->arr[++stack->top] = data;
}

int pop(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack-Unterlauf
");
        return -1;
    }
    return stack->arr[stack->top--];
}

int peek(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Der Stapel ist leer
");
        return -1;
    }
    return stack->arr[stack->top];
}

int main() {
    Stack stack;
    initialize(&stack);

    push(&stack, 10);
    push(&stack, 20);
    push(&stack, 30);

    printf("Oberstes Element: %d
", peek(&stack));

    printf("Entferntes Element: %d
", pop(&stack));
    printf("Entferntes Element: %d
", pop(&stack));

    printf("Oberstes Element: %d
", peek(&stack));

    return 0;
}
```
In diesem Programm definieren wir eine Stack-Struktur mit einem Array arr, um die Stapel-Elemente zu halten, und top, um den Index des obersten Elements zu verfolgen. Die initialize-Funktion initialisiert den Stapel, die isEmpty- und isFull-Funktionen überprüfen, ob der Stapel leer oder voll ist. Die push-Funktion fügt ein Element dem Stapel hinzu, die pop-Funktion entfernt und gibt das oberste Element zurück, und die peek-Funktion gibt das oberste Element zurück, ohne es zu entfernen. Die main-Funktion demonstriert die Verwendung dieser Stapeloperationen.

Beachte, dass diese Implementierung eine feste maximale Größe für den Stapel annimmt (in diesem Fall MAX_SIZE). Wenn du einen dynamisch anpassbaren Stapel benötigst, solltest du stattdessen eine verkettete Liste anstelle eines Arrays verwenden.
Hier ist eine Implementierung eines Stapels mit verketteten Listen in C:

```js
#include <stdio.h>
#include <stdlib.h>

struct Node {
  int data;
  struct Node* next;
};

struct Node* top = NULL; 

void push(int x) {

  struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  newNode->data = x;
  
  newNode->next = top;
  top = newNode;
}

void pop() {
  if(top == NULL) {
    printf("Stapel-Unterlauf
");
    return;
  }
  
  struct Node* temp = top;
  top = top->next;
  free(temp);
}

int peek() {

  if(top == NULL) {
    printf("Der Stapel ist leer
");
    return -1;
  }
  return top->data;
}

int main() {

  push(1);
  push(2); 
  push(3);

  printf("Element an der Spitze des Stapels: %d
",peek());

  pop();

  printf("Element an der Spitze des Stapels: %d
",peek());
  
  return 0;
}
```


In dieser Implementierung enthält jeder Knoten die Daten und einen Zeiger auf den nächsten Knoten. push() allokiert einen neuen Knoten, setzt seine Daten und lässt ihn auf das vorherige oberste Element zeigen. pop() gibt den durch top angezeigten Knoten frei und bewegt top zum nächsten Knoten. peek() gibt einfach die Daten des durch top angezeigten Knotens zurück.