Program: ma3
This commit is contained in:
parent
be0e538ff4
commit
517c976643
57
MA3/josephus.c
Normal file
57
MA3/josephus.c
Normal file
@ -0,0 +1,57 @@
|
||||
/**********************************************************************\
|
||||
* Kurzbeschreibung:
|
||||
* Realisiert das Josephus Spiel zum Test einer Queue
|
||||
*
|
||||
* Datum: Autor:
|
||||
* 30.9.2015 Prof. Dr. Helmut Herold
|
||||
*
|
||||
\**********************************************************************/
|
||||
|
||||
/*--- #includes ------------------------------------------------------*/
|
||||
#define _CRT_SECURE_NO_WARNINGS //VC++: keine scanf() Warnungen
|
||||
#include <stdio.h> // Einbinden der Standard-Ein-/Ausgabefunktionen
|
||||
#include "queue.h" // Einbinden der selbstgeschriebenen Queue-Funktionen
|
||||
|
||||
/*--- #defines -------------------------------------------------------*/
|
||||
|
||||
/*--- Datentypen (typedef) -------------------------------------------*/
|
||||
|
||||
/*--- Prototypen lokaler Funktionen ----------------------------------*/
|
||||
|
||||
/*--- main -----------------------------------------------------------*/
|
||||
int main(void)
|
||||
{
|
||||
int n, z, i=1, nr; // n = Personenanzahl, z = wievielte wird entfernt, i = Laufvariable, nr = zum Prüfen von scanf
|
||||
|
||||
// Abfrage wie viele Personen mitspielen, solange wiederholen bis richtige Zahl eingegeben wurde
|
||||
do {
|
||||
printf("Wie viele Personen: "); // Frage ausgeben
|
||||
nr = scanf("%d", &n); getchar(); // Zahl einlesen und Eingabe bestätigen lassen
|
||||
} while (nr != 1 || n < 0); // solange wiederholen bis gültige Zahl
|
||||
|
||||
// Abfrage wievielte Person entfernt wird, auch hier wird auf korrekte Eingabe geprüft
|
||||
do {
|
||||
printf("Wie vielte ist auszusondern: "); // Frage ausgeben
|
||||
nr = scanf("%d", &z); getchar(); // Zahl einlesen und Eingabe bestätigen lassen
|
||||
} while (nr != 1 || z < 0); // solange wiederholen bis gültige Zahl
|
||||
|
||||
// Die Queue wird mit Zahlen von 1 bis n gefüllt
|
||||
for (i = 1; i <= n; i++) // von 1 bis n
|
||||
put(i); // füge die Zahl in die Queue ein
|
||||
|
||||
// Solange die Queue nicht leer ist (also noch Personen da sind)
|
||||
while (!isEmpty()) {
|
||||
// Wiederhole z-1 mal: hole die vorderste Zahl aus der Queue und füge sie hinten wieder ein
|
||||
for (i = 1; i < z; i++) {
|
||||
if (put(get()) == FALSE) { // Zahl nach hinten verschieben, wenn das schief geht:
|
||||
fprintf(stderr, "Fehler beim Einfügen\n"); // Fehlermeldung
|
||||
return 1; // Programm abbrechen mit Fehler
|
||||
}
|
||||
}
|
||||
// Jetzt hole die vorderste Zahl (die z-te) und gib sie aus (sie wird entfernt)
|
||||
printf("%d, ", get()); // Zahl ausgeben und aus Queue entfernen (nicht mehr einfügen)
|
||||
}
|
||||
printf("\n"); // Zeilenumbruch am Ende
|
||||
|
||||
return 0; // Programm endet erfolgreich
|
||||
}
|
BIN
MA3/josephus.exe
Executable file
BIN
MA3/josephus.exe
Executable file
Binary file not shown.
BIN
MA3/josephus.o
Normal file
BIN
MA3/josephus.o
Normal file
Binary file not shown.
BIN
MA3/libqueue.a
Normal file
BIN
MA3/libqueue.a
Normal file
Binary file not shown.
122
MA3/queue.c
Normal file
122
MA3/queue.c
Normal file
@ -0,0 +1,122 @@
|
||||
/**********************************************************************\
|
||||
* Kurzbeschreibung:
|
||||
* queue.c - realisiert eine Queue (Warteschlange)
|
||||
*
|
||||
* Datum: Autor:
|
||||
*
|
||||
*
|
||||
\**********************************************************************/
|
||||
|
||||
/*--- #includes ------------------------------------------------------*/
|
||||
#include <stdio.h> // Standard Ein-/Ausgabe
|
||||
#include <stdlib.h> // Für malloc und free
|
||||
#include "queue.h" // Für die Typen und Funktionsdeklarationen
|
||||
|
||||
/*--- Modulglobale static Variablen ----------------------------------*/
|
||||
// Das sind Zeiger auf das erste und letzte Element der Queue.
|
||||
// Sie sind nur hier sichtbar (static = nur in dieser Datei).
|
||||
static Queue_Elem *Anfang_Element = NULL; // Zeigt auf das erste Element in der Queue
|
||||
static Queue_Elem *Ende_Element = NULL; // Zeigt auf das letzte Element in der Queue
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Einfuegen in Liste
|
||||
* Parameter:
|
||||
* zahl fügt die übergebene Zahl 'zahl' am Ende der Liste ein
|
||||
* Return Wert:
|
||||
* TRUE wenn noch genug Speicherplatz vorhanden
|
||||
* FALSE wenn kein Speicherplatz mehr allokiert werden konnte
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool put(int zahl)
|
||||
{
|
||||
// Speicherplatz für ein neues Element anfordern
|
||||
Queue_Elem* neues_Element = (Queue_Elem*)malloc(sizeof(Queue_Elem));
|
||||
|
||||
// Prüfen, ob der Speicher angelegt werden konnte
|
||||
if (neues_Element == NULL)
|
||||
{
|
||||
return FALSE; // Fehler, kein Speicher mehr
|
||||
}
|
||||
else
|
||||
{
|
||||
neues_Element->wert = zahl; // Wert setzen
|
||||
neues_Element->Element_next = NULL; // Nächstes Element gibt es noch nicht
|
||||
neues_Element->Element_prev = NULL; // Vorheriges Element gibt es noch nicht
|
||||
|
||||
// Wenn Queue noch leer ist (erstes Element)
|
||||
if (Anfang_Element == NULL)
|
||||
{
|
||||
Anfang_Element = neues_Element; // Sowohl Anfang als auch Ende zeigen auf das neue Element
|
||||
Ende_Element = neues_Element;
|
||||
}
|
||||
else // Sonst: Am Ende anhängen
|
||||
{
|
||||
if (Ende_Element != NULL)
|
||||
{
|
||||
Ende_Element->Element_next = neues_Element; // Das aktuelle Ende zeigt auf das neue Element
|
||||
neues_Element->Element_prev = Ende_Element; // Das neue Element weiß, was vorher war
|
||||
Ende_Element = neues_Element; // Das neue Element ist jetzt das Ende
|
||||
}
|
||||
}
|
||||
}
|
||||
return TRUE; // Hat geklappt!
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Auslesen aus Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* Zahl am Anfang der Liste oder aber QLEER, wenn Liste leer ist.
|
||||
*--------------------------------------------------------------------*/
|
||||
int get(void)
|
||||
{
|
||||
int zahl;
|
||||
// Zeiger auf das erste Element (wird gleich gelöscht)
|
||||
Queue_Elem* temp = Anfang_Element;
|
||||
|
||||
// Wenn mindestens ein Element in der Queue ist
|
||||
if(Anfang_Element != NULL && Ende_Element != NULL)
|
||||
{
|
||||
zahl = (Anfang_Element)->wert; // Wert des ersten Elements speichern
|
||||
|
||||
// Wenn es noch mehr als ein Element gibt
|
||||
if(Anfang_Element->Element_next != NULL)
|
||||
{
|
||||
Anfang_Element->Element_next->Element_prev = NULL; // Das neue Erste zeigt auf nix vorher
|
||||
Anfang_Element = Anfang_Element->Element_next; // Anfang_Element zeigt jetzt auf das neue Erste
|
||||
}
|
||||
else // Es gibt nur ein Element (das wird jetzt gelöscht)
|
||||
{
|
||||
Anfang_Element = NULL;
|
||||
Ende_Element = NULL;
|
||||
}
|
||||
|
||||
free(temp); // Speicherplatz freigeben
|
||||
}
|
||||
else // Die Queue ist leer
|
||||
{
|
||||
zahl = QLEER; // Rückgabewert für "leer"
|
||||
}
|
||||
|
||||
return zahl; // Zahl oder QLEER zurückgeben
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Pruefen der Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* liefert TRUE, wenn Queue leer ist, sonst FALSE
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool isEmpty(void)
|
||||
{
|
||||
// Ist Anfang und Ende auf NULL -> Queue ist leer
|
||||
if(Anfang_Element == NULL && Ende_Element == NULL)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
}
|
63
MA3/queue.h
Normal file
63
MA3/queue.h
Normal file
@ -0,0 +1,63 @@
|
||||
/**********************************************************************\
|
||||
* Kurzbeschreibung:
|
||||
* queue.h - realisiert eine Queue (Warteschlange) als verkettete Liste
|
||||
*
|
||||
* Datum: Autor:
|
||||
* 30.9.2015 Prof. Dr. Helmut Herold
|
||||
*
|
||||
\**********************************************************************/
|
||||
#ifndef QUEUE_H
|
||||
#define QUEUE_H
|
||||
|
||||
/*--- #includes ------------------------------------------------------*/
|
||||
#include <limits.h> // Für INT_MIN
|
||||
|
||||
/*--- #defines -------------------------------------------------------*/
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#define QLEER INT_MIN // Konstante, um "Queue ist leer" zu kennzeichnen
|
||||
|
||||
/*--- Datentypen (typedef) -------------------------------------------*/
|
||||
typedef int Bool; // Bool ist einfach nur ein int
|
||||
|
||||
// Struktur für ein Queue-Element
|
||||
typedef struct Queue_Element {
|
||||
int wert; // Der gespeicherte Wert (die Zahl)
|
||||
struct Queue_Element* Element_next; // Zeiger auf das nächste Element
|
||||
struct Queue_Element* Element_prev; // Zeiger auf das vorherige Element
|
||||
} Queue_Elem;
|
||||
|
||||
/*--- Prototypen globaler Funktionen ---------------------------------*/
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Einfuegen in Liste
|
||||
* Parameter:
|
||||
* zahl fügt die übergebene Zahl 'zahl' am Ende der Liste ein
|
||||
* Return Wert:
|
||||
* TRUE wenn noch genug Speicherplatz vorhanden
|
||||
* FALSE wenn kein Speicherplatz mehr allokiert werden konnte
|
||||
* Hinweis:
|
||||
* - dynamische Verwaltung von Speicher muss mit malloc() und free()
|
||||
* durchgeführt werden; dynamische Arrays sind nicht erlaubt !!!
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool put(int zahl);
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Auslesen aus Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* Zahl am Anfang der Liste oder aber QLEER, wenn Liste leer ist.
|
||||
*--------------------------------------------------------------------*/
|
||||
int get(void);
|
||||
|
||||
/*--------------------------------------------------------------------*\
|
||||
* Pruefen der Liste
|
||||
* Parameter:
|
||||
* keine
|
||||
* Return Wert:
|
||||
* liefert TRUE, wenn Queue leer ist, sonst FALSE
|
||||
*--------------------------------------------------------------------*/
|
||||
Bool isEmpty(void);
|
||||
|
||||
#endif /*QUEUE_H*/
|
BIN
MA3/queue.o
Normal file
BIN
MA3/queue.o
Normal file
Binary file not shown.
Loading…
x
Reference in New Issue
Block a user