programs ch 11

skript/kapitel_11/points

+2 3 
+4 5 
+6 7 
+8 9 
+10 11

skript/kapitel_11/queue.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, Implementierung
+*
+**************************************/
+
+#include<stdio.h>
+#include<stdlib.h>
+#include <limits.h>
+
+#include "queue.h"
+
+static struct node* init_node(int value) {
+  struct node * node = (struct node *)malloc(sizeof(struct node));
+  node->value = value;
+  node->next = NULL;
+  return node;
+}
+
+static void free_node(struct node * node) {
+  free(node);
+}
+
+void print_queue(const struct node * node) {
+  static int count = 1;
+  printf("Aufruf %d , die Liste enthaelt: ", count++);
+  while (node != NULL ) {
+    printf("%d ", node->value);
+    node = node->next;
+  }
+  printf("\n");
+}
+
+void free_queue(struct node * node ) {
+  struct node* keep = NULL;
+  while( node != NULL ) {
+    keep = node;
+    node = node->next;
+    free_node(keep);
+  }
+}
+
+void enqueue(struct node **head_ptr, int value) {
+  struct node* new_node = init_node(value);
+
+  if ( *head_ptr == NULL ) { 
+    *head_ptr = new_node;
+  } else {
+    struct node* node = *head_ptr; 
+    while ( node->next != NULL ) {
+      node = node->next; 
+    }
+    node->next = new_node; 
+  }
+}
+
+int dequeue(struct node **head_ptr) {
+  int value = INT_MIN;
+  if( *head_ptr ) {
+    struct node * node = *head_ptr;
+    value = node->value;
+    *head_ptr = node->next;
+    free(node);
+  }
+
+  return value;
+}
+
+int queue_is_empty(struct node * head) {
+    return ( head == NULL );
+}
+
+int peek_queue(struct node * head) {
+  int value = INT_MIN;
+  if( head ) {
+    value = head->value;
+  }
+
+  return value;
+}

skript/kapitel_11/queue.h

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, Header
+*
+**************************************/
+
+#ifndef QUEUE_H
+#define QUEUE_H
+
+#ifndef NODE_STRUCT
+#define NODE_STRUCT
+struct node {
+  int value;
+  struct node * next;
+};
+
+#endif
+
+void print_queue(const struct node *);
+void free_qeuue(struct node *);
+
+void enqueue(struct node **, int);
+int dequeue(struct node **);
+int queue_is_empty(struct node *);
+int peek_queue(struct node *);
+
+#endif

skript/kapitel_11/queue_main.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, main
+*
+* Uebersetzen mit
+* gcc queue_main.c -o queue
+* Aufruf mit
+* ./queue
+**************************************/
+
+#include<stdio.h>
+#include<stdlib.h>
+
+#include "queue.h"
+
+int main() {
+
+  // Initialisierung
+  struct node * head = NULL;
+
+  print_list(head);
+  
+  enqueue(&head, 17);
+  enqueue(&head, 22);
+  enqueue(&head, 30);
+  print_list(head);
+
+  int value = dequeue(&head);
+  printf("Wert %d zurueckbekommen\n",value);
+  print_list(head);
+  
+  value = dequeue(&head);
+  printf("Wert %d zurueckbekommen\n",value);
+  print_list(head);
+  printf("Liste ist leer: %s\n", is_empty(head)?"ja":"nein" );
+  printf("Das naechste Element ist %d\n", peek(head));
+
+  value = dequeue(&head);
+  printf("%d vom Anfang der Liste genommen\n",value);
+  print_list(head);
+  dequeue(&head);
+  print_list(head);
+
+  printf("Liste ist leer: %s\n", is_empty(head)?"ja":"nein" );
+  printf("Das naechste Element ist %d\n", peek(head));
+
+  free_list(head);
+
+  return 0;
+}

skript/kapitel_11/queue_main_v2.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, main, mit tail pointer
+*
+* Uebersetzen mit
+* gcc queue_main_v2.c -o queue
+* Aufruf mit
+* ./queue
+**************************************/
+
+#include<stdio.h>
+
+#include "queue_v2.h"
+
+int main() {
+
+  // Initialisierung
+  struct node * head = NULL;
+  struct node * tail = NULL;
+
+  print_list(head);
+  
+  enqueue(&head, &tail, 17);
+  enqueue(&head, &tail, 22);
+  enqueue(&head, &tail, 30);
+  print_list(head);
+
+  int value = dequeue(&head, &tail);
+  printf("Wert %d zurueckbekommen\n",value);
+  print_list(head);
+  
+  value = dequeue(&head, &tail);
+  printf("Wert %d zurueckbekommen\n",value);
+  print_list(head);
+  printf("Liste ist leer: %s\n", is_empty(head)?"ja":"nein" );
+  printf("Das naechste Element ist %d\n", peek(head));
+
+  value = dequeue(&head, &tail);
+  printf("%d vom Anfang der Liste genommen\n",value);
+  print_list(head);
+  dequeue(&head, &tail);
+  print_list(head);
+
+  printf("Liste ist leer: %s\n", is_empty(head)?"ja":"nein" );
+
+  free_list(head);
+
+  return 0;
+}

skript/kapitel_11/queue_tailptr.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, Implementierung mit tail pointer
+*
+**************************************/
+
+#include<stdio.h>
+#include<stdlib.h>
+#include <limits.h>
+
+#include "queue_tailptr.h"
+
+static struct node* init_node(int value) {
+  struct node * node = (struct node *)malloc(sizeof(struct node));
+  node->value = value;
+  node->next = NULL;
+  return node;
+}
+
+static void free_node(struct node * node) {
+  free(node);
+}
+
+void free_queue(struct node * node ) {
+  struct node* keep = NULL;
+  while( node != NULL ) {
+    keep = node;
+    node = node->next;
+    free_node(keep);
+  }
+}
+
+void enqueue(struct node **head_ptr, struct node** tail_ptr, int value) {
+  struct node* new_node = init_node(value);
+
+  if ( *head_ptr == NULL ) { 
+    *head_ptr = new_node;
+    *tail_ptr = new_node;
+  } else {
+    (*tail_ptr)->next = new_node;
+    *tail_ptr = new_node;
+  }
+}
+
+int dequeue(struct node **head_ptr, struct node ** tail_ptr) {
+  int value = INT_MIN;
+  if( *head_ptr != NULL ) {
+    struct node * node = *head_ptr;
+    value = node->value;
+    *head_ptr = node->next;
+    free(node);
+  }
+  if ( *head_ptr == NULL ) {
+      *tail_ptr = NULL;
+  }
+  return value;
+}
+
+int is_empty(struct node * head) {
+    return ( head == NULL );
+}
+
+int peek(struct node * head) {
+  int value = INT_MIN;
+  if( head ) {
+    value = head->value;
+  }
+
+  return value;
+}
+
+void print_queue(const struct node * node) {
+  static int count = 1;
+  printf("Aufruf %d , die Liste enthaelt: ", count++);
+  while (node != NULL ) {
+    printf("%d ", node->value);
+    node = node->next;
+  }
+  printf("\n");
+}
\ No newline at end of file

skript/kapitel_11/queue_tailptr.h

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, Header zur Implementierung mit tail pointer
+*
+**************************************/
+
+
+#ifndef QUEUE_TAILPTR_H
+#define QUEUE_TAILPTR_H
+
+#ifndef NODE_STRUCT
+#define NODE_STRUCT
+
+struct node {
+  int value;
+  struct node * next;
+};
+
+#endif
+
+void free_queue(struct node *);
+
+void enqueue(struct node **head_ptr, struct node** tail_ptr, int value);
+int dequeue(struct node **head_ptr, struct node ** tail_ptr);
+int is_empty(struct node *);
+int peek(struct node *);
+
+void print_queue(const struct node *);
+
+#endif

skript/kapitel_11/queue_tailptr_runtime.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, main, mit tail pointer mit Laufzeitmessung
+*
+* Uebersetzen mit
+* gcc queue_tailptr_runtime.c queue_tail_ptr.c -o queue
+* Aufruf mit
+* ./queue
+**************************************/
+
+#include<stdio.h>
+#include<stdlib.h>
+#include <limits.h>
+#include <time.h>
+
+#include "queue_tailptr.h"
+
+#define LAENGE 50000
+
+int main() {
+
+  // Initialisierung
+  struct node * head = NULL;
+  struct node * tail = NULL;
+
+  srand(time(0));
+  clock_t anfang = clock();
+  for ( int i = 0; i < LAENGE; ++i ) {
+      enqueue(&head, &tail, rand()%1000);
+  }
+
+  clock_t ende = clock();
+  double zeit = ((double) (ende - anfang)) / CLOCKS_PER_SEC;
+
+  free_queue(head);
+
+  printf("%d Elemente in %f Sekunden an die Warteschlange angehaengt\n",LAENGE,zeit);
+
+  return 0;
+}

skript/kapitel_11/queue_v2.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, Header, mit tail pointer
+*
+**************************************/
+
+#include<stdio.h>
+#include<stdlib.h>
+#include <limits.h>
+#include "queue_v2.h"
+
+struct node* init_node(int value) {
+  struct node * node = (struct node *)malloc(sizeof(struct node));
+  node->value = value;
+  node->next = NULL;
+  return node;
+}
+
+void free_node(struct node * node) {
+  free(node);
+}
+
+void print_list(const struct node * node) {
+  static int count = 1;
+  printf("Aufruf %d , die Liste enthaelt: ", count++);
+  while (node != NULL ) {
+    printf("%d ", node->value);
+    node = node->next;
+  }
+  printf("\n");
+}
+
+void free_list(struct node * node ) {
+  struct node* keep = NULL;
+  while( node != NULL ) {
+    keep = node;
+    node = node->next;
+    free_node(keep);
+  }
+}
+
+void enqueue(struct node **head_ptr, struct node** tail_ptr, int value) {
+  struct node* new_node = init_node(value);
+
+  if ( *head_ptr == NULL ) { 
+    *head_ptr = new_node;
+    *tail_ptr = new_node;
+  } else {
+    (*tail_ptr)->next = new_node;
+    *tail_ptr = new_node;
+  }
+}
+
+int dequeue(struct node **head_ptr, struct node ** tail_ptr) {
+  int value = INT_MIN;
+  if( *head_ptr != NULL ) {
+    struct node * node = *head_ptr;
+    value = node->value;
+    *head_ptr = node->next;
+    free(node);
+  }
+  if ( *head_ptr == NULL ) {
+      *tail_ptr = NULL;
+  }
+  return value;
+}
+
+int is_empty(struct node * head) {
+    return ( head == NULL );
+}
+
+int peek(struct node * head) {
+  int value = INT_MIN;
+  if( head ) {
+    value = head->value;
+  }
+
+  return value;
+}

skript/kapitel_11/queue_v2.h

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, Header, mit tail pointer
+*
+**************************************/
+
+#ifndef QUEUE_V2_H
+#define QUEUE_V2_H
+
+struct node {
+  int value;
+  struct node * next;
+};
+
+struct node* init_node(int);
+void free_node(struct node *);
+void print_list(const struct node *);
+void free_list(struct node *);
+
+void enqueue(struct node **head_ptr, struct node** tail_ptr, int value);
+int dequeue(struct node **head_ptr, struct node ** tail_ptr);
+int is_empty(struct node *);
+int peek(struct node *);
+
+#endif

skript/kapitel_11/runtime.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* queue, main, mit Laufzeitmessung
+*
+* Uebersetzen mit
+* gcc queue_runtime.c queue.c -o queue
+* Aufruf mit
+* ./queue
+**************************************/
+
+#include<stdio.h>
+#include<stdlib.h>
+#include <limits.h>
+#include <time.h>
+
+#include "stack.h"
+#include "queue.h"
+
+#define LAENGE 50000
+
+int main() {
+
+  // Initialisierung
+  struct node * head = NULL;
+
+  srand(time(0));
+  clock_t anfang = clock();
+  for ( int i = 0; i < LAENGE; ++i ) {
+      push(&head,rand()%1000);
+  }
+
+  clock_t ende = clock();
+  double zeit = ((double) (ende - anfang)) / CLOCKS_PER_SEC;
+
+  printf("%d Elemente in %f Sekunden auf den Stapel gelegt\n",LAENGE,zeit);
+
+  free_stack(head);
+  head = NULL;
+
+  srand(time(0));
+  anfang = clock();
+
+  for ( int i = 0; i < 50000; ++i ) {
+      enqueue(&head,rand()%1000);
+  }
+
+  ende = clock();
+  zeit = ((double) (ende - anfang)) / CLOCKS_PER_SEC;
+
+  printf("%d Elemente in %f Sekunden an die Warteschlange angehaengt\n",LAENGE,zeit);
+
+  free_queue(head);
+
+  return 0;
+}

skript/kapitel_11/stack.c

+/*************************************
+* Beispielprogramm zur Vorlesung
+* Einfuehrung in die Programmierung I
+* Andreas Paffenholz
+* TU Darmstadt, Wintersemester 2020/21
+* (c) 2020-
+*
+* stack, Implementierung
+*
+**************************************/
+
+#include<stdio.h>
+#include<stdlib.h>
+#include <limits.h>
+
+#include "stack.h"
+
+/*
+ * Initialisieren und Löschen des Stapels
+ */
+
+static struct node* init_node(int value) {
+  struct node * node = (struct node *)malloc(sizeof(struct node));
+  node->value = value;
+  node->next = NULL;
+  return node;
+}
+
+static void free_node(struct node * node) {
+  free(node);
+}
+
+void free_stack(struct node * node ) {
+  struct node* keep = NULL;