Algorithmen und Datenstrukturen in C/ Stapelspeicher

Aus Wikibooks
Zur Navigation springen Zur Suche springen
Wikipedia hat einen Artikel zum Thema:

Ein Stapelspeicher (oder Stack) ist eine spezielle Datenstruktur, mit der beliebige Daten verwaltet werden können.

Funktionsweise der grundlegenden Stapeloperationen pop und push.

Auf einem Stack sind zwei Operationen definiert:

pop 
Einen Wert vom Stapelspeicher entfernen.
push 
Einen Wert auf den Stapelspeicher legen.

Diese Operationen wirken sich immer auf die Spitze des Stapelspeichers aus, daher ist der Stapel ein sogenannter LIFO-Speicher (Last In First Out). Dies ist in der nebenstehenden Abbildung dargestellt.

Implementation[Bearbeiten]

Ein Stapelspeicher kann auf verschiedene Weisen implementiert werden, im Folgenden sollen zwei Möglichkeiten besprochen werden.

Hierfür sei zunächst die folgende Schnittstelle vereinbart:

#define SUCCESS 0
#define ERR_INVAL 1
#define ERR_NOMEM 2

#define FALSE 0
#define TRUE 1

typedef struct stack_s stack_t;

int stack_destroy(stack_t *stack);
int stack_empty(stack_t *stack);
stack_t *stack_new(void);
void *stack_pop(stack_t *stack);
int stack_push(stack_t *stack, void *data);

Implementation mit Verkettung[Bearbeiten]

Zunächst soll eine Implementation besprochen werden, die auf einer einfach verketteten Liste basiert. Diese Implementation hat den Vorteil, dass die Größe des Stapelspeichers stets mit der Anzahl der Elemente, die auf dem Stapelspeicher liegen, übereinstimmt. Nachteilig ist, dass der Speicherverbrauch hoch ist, da für jedes einzelne Element eine Struktur benötigt wird, die neben dem Zeiger auf die Daten auch einen Zeiger auf das nächste Element speichert. Außerdem ist das Einfügen und Auslesen von Elementen nicht in konstanter Zeit möglich, da hierbei stets Speicheroperationen ausgeführt werden.

Diese Implementation verwendet die folgenden Datenstrukturen:

struct stack_frame_s {
  struct stack_frame_s *next;
  void *data;
};

struct stack_s {
  struct stack_frame_s *top;
};

Damit lassen sich die Funktionen folgendermaßen implementieren:

 1 int stack_destroy(stack_t *stack) {
 2   if (stack == NULL) {
 3     return ERR_INVAL;
 4   }
 5   while (stack->top != NULL) {
 6     struct stack_frame_s *frame = stack->top;
 7     stack->top = frame->next;
 8     free(frame);
 9   }
10   free(stack);
11   return SUCCESS;
12 }
13 
14 int stack_empty(stack_t *stack) {
15   if (stack == NULL || stack->top == NULL) {
16     return TRUE;
17   } else {
18     return FALSE;
19   }
20 }
21 
22 stack_t *stack_new(void) {
23   stack_t *stack = malloc(sizeof(*stack));
24   if (stack == NULL) {
25     return NULL;
26   }
27   stack->top = NULL;
28   return stack;
29 }
30 
31 void *stack_pop(stack_t *stack) {
32   if (stack == NULL || stack->top == NULL) {
33     return NULL;
34   }
35   struct stack_frame_s *frame = stack->top;
36   void *data = frame->data;
37   stack->top = frame->next;
38   free(frame);
39   return data;
40 }
41 
42 int stack_push(stack_t *stack, void *data) {
43   if (stack == NULL) {
44     return ERR_INVAL;
45   }
46   struct stack_frame_s *frame = malloc(sizeof(*frame));
47   if (frame == NULL) {
48     return ERR_NOMEM;
49   }
50   frame->data = data;
51   frame->next = stack->top;
52   stack->top = frame;
53   return SUCCESS;
54 }

Implementation mit einem Feld[Bearbeiten]

Außerdem soll eine Implementation besprochen werden, die ein Feld für die Datenspeicherung verwendet. Dieses hat im Gegensatz zu der oben besprochenen Implementation den Vorteil, dass der Speicherverbrauch für ein einzelnes Element geringer ist, da kein Zeiger auf das nachfolgende Element notwendig ist. Außerdem ist der Zugriff auf die Elemente in konstanter Zeit möglich, solange keine Speicheroperationen durchgeführt werden müssen. Diese Vorteile setzen allerdings voraus, dass die Parameter

STACK_GROW_SIZE 
Anzahl von Speicherplätzen, um die der Stapelspeicher bei Größenänderung wachsen soll. Die Implementation ist so angelegt, dass beim Verkleinern des Stapelspeichers die Anzahl der verfügbaren Speicherplätze ein ganzzahliges Vielfaches dieser Größe ist.
STACK_INIT_SIZE 
Initiale Anzahl von Speicherplätzen.
STACK_SHRINK_AT 
Die Anzahl freier Speicherplätze, die mindestens vorhanden sein müssen, um den Stapelspeicher zu verkleinern.

für das Problem geeignet gewählt werden, insbesondere ist bei der vorliegenden Implementation der Speicherverbrauch (ohne Berücksichtigung der Verwaltungsstrukturen des Betriebssystems) nur dann geringer, wenn die Anzahl der Elemente auf dem Stapelspeicher mindestens die Hälfte der möglichen Elemente ist (d.h. bei einem Stapelspeicher, der zehn Elemente ohne Speicheroperationen aufnehmen kann, müssen mindestens fünf Elemente auf dem Stapelspeicher liegen).

Diese Implementation verwendet die folgenden Datenstrukturen:

struct stack_s {
  void **bottom;
  size_t len;
  size_t size;
};

Damit lassen sich die Funktionen folgendermaßen implementieren:

 1 int stack_destroy(stack_t *stack) {
 2   if (stack == NULL) {
 3     return ERR_INVAL;
 4   }
 5   free(stack->bottom);
 6   free(stack);
 7   return SUCCESS;
 8 }
 9 
10 int stack_empty(stack_t *stack) {
11   if (stack == NULL || stack->len == 0) {
12     return TRUE;
13   } else {
14     return FALSE;
15   }
16 }
17 
18 stack_t *stack_new(void) {
19   stack_t *stack = malloc(sizeof(*stack));
20   if (stack == NULL) {
21     return NULL;
22   }
23   if ((stack->bottom = malloc(STACK_INIT_SIZE*sizeof(*(stack->bottom)))) == NULL) {
24     free(stack);
25     return 0;
26   }
27   stack->size = STACK_INIT_SIZE;
28   stack->len = 0;
29   return stack;
30 }
31 
32 void *stack_pop(stack_t *stack) {
33   if (stack == NULL || stack->len == 0) {
34     return NULL;
35   }
36   void *data = stack->bottom[--(stack->len)];
37   if ((stack->size - stack->len) >= STACK_SHRINK_AT) {
38     size_t new_size = stack->len + (stack->len + STACK_GROW_SIZE) % STACK_GROW_SIZE;
39     stack->bottom = realloc(stack->bottom, new_size*sizeof(*(stack->bottom)));
40     stack->size = new_size;
41   }
42   return data;
43 }
44 
45 int stack_push(stack_t *stack, void *data) {
46   if (stack == NULL) {
47     return ERR_INVAL;
48   }
49   if (stack->len == stack->size) {
50     size_t new_size = stack->size + STACK_GROW_SIZE;
51     void **new_bottom = realloc(stack->bottom, new_size*sizeof(*(stack->bottom)));
52     if (new_bottom == NULL) {
53       return ERR_NOMEM;
54     }
55     stack->bottom = new_bottom;
56     stack->size = new_size;
57   }
58   stack->bottom[(stack->len)++] = data;
59   return SUCCESS;
60 }

Anwendungsbeispiel[Bearbeiten]

Als Anwendungsbeispiel sei hier eine iterative Tiefensuche in einem Binärbaum behandelt (siehe dort für die Definition von knoten):

 1 void dfs(knoten *tree, void (*f)(int, void *), void *user) {
 2   if (tree == NULL) {
 3     return;
 4   }
 5   stack_t *stack = stack_new();
 6   stack_push(stack, tree);
 7   while (!stack_empty(stack)) {
 8     knoten *k = stack_pop(stack);
 9     if (k->rechts != NULL) {
10       stack_push(stack, k->rechts);
11     }
12     if (k->links != NULL) {
13       stack_push(stack, k->links);
14     }
15     (*f)(k->wert, user);
16   }
17   stack_destroy(stack);
18 }

Hierbei ist f eine Funktion, die auf jedem Knoten ausgeführt werden soll, z.B.

1 void print(int n, void *user) {
2   if (*((int *)user)) {
3     *((int *)user) = 0;
4   } else {
5     printf(", ");
6   }
7   printf("%d", n);
8 }

um die Knotenwerte auszugeben.