Commit 3986048c authored by Paffenholz, Andreas's avatar Paffenholz, Andreas

programs ch 11

parent e130b9da
2 3
4 5
6 7
8 9
10 11
/*************************************
* 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;
}
/*************************************
* 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
/*************************************
* 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;
}
/*************************************
* 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;
}
/*************************************
* 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
/*************************************
* 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
/*************************************
* 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;
}
/*************************************
* 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;
}
/*************************************
* 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
/*************************************
* 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;
}
/*************************************
* 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;