Program: ma3

This commit is contained in:
Alex Chilab 2025-05-29 20:22:06 +02:00
parent be0e538ff4
commit 517c976643
7 changed files with 242 additions and 0 deletions

57
MA3/josephus.c Normal file
View 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

Binary file not shown.

BIN
MA3/josephus.o Normal file

Binary file not shown.

BIN
MA3/libqueue.a Normal file

Binary file not shown.

122
MA3/queue.c Normal file
View 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
View 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

Binary file not shown.