hennichso96878/Info2P5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

halo

Browse Source
This commit is contained in:
Bora Zuenbuelkoek 2025-06-12 08:10:22 +02:00
parent d48bacbae7
commit fc0ecd6b27
5 changed files with 253 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
Modul4/automat.c
View File

@ -8,104 +8,107 @@
* *
* *
\**********************************************************************/ \**********************************************************************/
#include <stdio.h> #include <stdio.h> // Standard Ein-/Ausgabe
#include <stdlib.h> #include <stdlib.h> // Standardbibliothek (z.B. für malloc)
#include "automat.h" #include "automat.h" // Eigene Headerdatei für Automatentypen und -funktionen
/*--- #defines -------------------------------------------------------*/ /*--- #defines -------------------------------------------------------*/
/* Macro zur Ermittlung der Array Groesse */ /* Macro zur Ermittlung der Array Groesse */
#define SIZE_OF(a) (sizeof((a))/ sizeof(*(a))) #define SIZE_OF(a) (sizeof((a))/ sizeof(*(a))) // Gibt die Anzahl der Elemente eines Arrays zurück
#define NR_OF_STATES (I-A+1) // Achtung: A=0, I=8, ergibt 9 Zustände #define NR_OF_STATES (I-A + 1) // Anzahl der Zustände (Enum von A bis I)
/*--- Datentypen (typedef) -------------------------------------------*/ /*--- Datentypen (typedef) -------------------------------------------*/
/* Definition der Zustaende */ /* Definition der Zustaende */
typedef enum {A=0,B,C,D,E,F,G,H,I} state_t; typedef enum {A=0,B,C,D,E,F,G,H,I} state_t; // Aufzählung der Zustände von A bis I
/* Definition der fsm-spezifischen Variablen */
/* Struktur zur Beschreibung eines Uebergangs mit "Don't Care"-Moeglichkeit */ /* Struktur zur Beschreibung eines Uebergangs mit "Don't Care"-Moeglichkeit */
typedef struct { typedef struct {
int input; int input; // Erwarteter Eingabewert (Bitmaske)
int mask; int mask; // Maske für relevante Bits
state_t nxtstate; state_t nxtstate; // Zielzustand bei passender Eingabe
} fsm_state_t; } fsm_state_t;
/* Struktur zur Beschreibung aller Uebergaenge eines Zustands */ /* Struktur zur Beschreibung aller Uebergaenge eines Zustands */
typedef struct { typedef struct {
const fsm_state_t * transitions; const fsm_state_t * transitions; // Zeiger auf Array von Übergängen
int nrOfTransitions; int nrOfTransitions; // Anzahl der Übergänge
state_t defaultNxtState; state_t defaultNxtState; // Standard-Zielzustand, falls keine Transition passt
} fsm_full_state_t; } fsm_full_state_t;
/*--- Modulglobale static Variablen ----------------------------------*/ /*--- Modulglobale static Variablen ----------------------------------*/
/* Definition der Zustandsvariablen */ /* Definition der Zustandsvariablen */
static state_t s_curstate = A; /* Initialisierung */ static state_t s_curstate = A; /* Initialisierung */ // Aktueller Zustand, Start bei A
/* Definition aller Zustandsuebergaenge fuer jeden Zustand */ /* Definition aller Zustandsuebergaenge fuer jeden Zustand */
/* Die Masken sind invertiert, was ungewöhnlich ist, aber beibehalten. */ static const fsm_state_t s_transitions_A[] =
static const fsm_state_t s_transitions_A[] = { { /* input mask nxtstate */
/* input mask nxtstate */ { 0x002, ~0x004, B }, // Übergang zu B bei passender Eingabe
{ 0x002, ~0x004, B }, { 0x003, ~0x004, C } // Übergang zu C bei anderer Eingabe
{ 0x003, ~0x004, C }
}; };
static const fsm_state_t s_transitions_B[] = { static const fsm_state_t s_transitions_B[] =
{
{ 0x002, ~0x004, C }, { 0x002, ~0x004, C },
{ 0x003, ~0x004, D } { 0x003, ~0x004, D }
}; };
static const fsm_state_t s_transitions_C[] = { static const fsm_state_t s_transitions_C[] =
{
{ 0x002, ~0x004, D }, { 0x002, ~0x004, D },
{ 0x003, ~0x000, F }, { 0x003, ~0x000, F },
{ 0x007, ~0x000, H } { 0x007, ~0x000, H }
}; };
static const fsm_state_t s_transitions_D[] = { static const fsm_state_t s_transitions_D[] =
{
{ 0x002, ~0x000, F }, { 0x002, ~0x000, F },
{ 0x003, ~0x004, E }, { 0x003, ~0x004, E },
{ 0x006, ~0x000, H } { 0x006, ~0x000, H }
}; };
static const fsm_state_t s_transitions_E[] = { static const fsm_state_t s_transitions_E[] =
{
{ 0x002, ~0x000, F }, { 0x002, ~0x000, F },
{ 0x003, ~0x004, E }, { 0x003, ~0x004, E },
{ 0x006, ~0x000, H } { 0x006, ~0x000, H }
}; };
static const fsm_state_t s_transitions_F[] = { static const fsm_state_t s_transitions_F[] =
{
{ 0x002, ~0x001, G }, { 0x002, ~0x001, G },
{ 0x004, ~0x001, H }, { 0x004, ~0x001, H },
{ 0x006, ~0x001, I } { 0x006, ~0x001, I }
}; };
static const fsm_state_t s_transitions_G[] = { static const fsm_state_t s_transitions_G[] =
{
{ 0x002, ~0x001, G }, { 0x002, ~0x001, G },
{ 0x004, ~0x001, H }, { 0x004, ~0x001, H },
{ 0x006, ~0x001, I } { 0x006, ~0x001, I }
}; };
static const fsm_state_t s_transitions_H[] = { static const fsm_state_t s_transitions_H[] =
{
{ 0x000, ~0x001, A }, { 0x000, ~0x001, A },
{ 0x002, ~0x000, B }, { 0x002, ~0x000, B },
{ 0x003, ~0x000, C }, { 0x003, ~0x000, C },
{ 0x006, ~0x001, I } { 0x006, ~0x001, I }
}; };
static const fsm_state_t s_transitions_I[] = { static const fsm_state_t s_transitions_I[] =
{
{ 0x000, ~0x001, A }, { 0x000, ~0x001, A },
{ 0x002, ~0x000, B }, { 0x002, ~0x000, B },
{ 0x003, ~0x000, C }, { 0x003, ~0x000, C },
{ 0x006, ~0x001, I } { 0x006, ~0x001, I }
}; };
/* Definition der Uebergangstabelle */ /* Definition der Uebergangstabelle */
/* Die Reihenfolge der Zustaende in der enum Definition muss der /* Die Reihenfolge der Zustaende in der enum Definition muss der
* Reihenfolge der Zustaende in der Uebergangstabelle entsprechen */ * Reihenfolge der Zustaende in der Uebergangstabelle entsprechen
static const fsm_full_state_t s_state_table[NR_OF_STATES] = { * [Zeile] [Spalte] */
static const fsm_full_state_t s_state_table[NR_OF_STATES] =
{
/* transitions nrOfTransitions defaultNxtState */ /* transitions nrOfTransitions defaultNxtState */
{ s_transitions_A, SIZE_OF(s_transitions_A), A }, { s_transitions_A, SIZE_OF(s_transitions_A), A }, // Zustand A
{ s_transitions_B, SIZE_OF(s_transitions_B), B }, { s_transitions_B, SIZE_OF(s_transitions_B), B }, // Zustand B
{ s_transitions_C, SIZE_OF(s_transitions_C), C }, { s_transitions_C, SIZE_OF(s_transitions_C), C }, // Zustand C
{ s_transitions_D, SIZE_OF(s_transitions_D), A }, { s_transitions_D, SIZE_OF(s_transitions_D), D }, // Zustand D
{ s_transitions_E, SIZE_OF(s_transitions_E), D }, { s_transitions_E, SIZE_OF(s_transitions_E), D }, // Zustand E
{ s_transitions_F, SIZE_OF(s_transitions_F), F }, { s_transitions_F, SIZE_OF(s_transitions_F), F }, // Zustand F
{ s_transitions_G, SIZE_OF(s_transitions_G), F }, { s_transitions_G, SIZE_OF(s_transitions_G), F }, // Zustand G
{ s_transitions_H, SIZE_OF(s_transitions_H), H }, { s_transitions_H, SIZE_OF(s_transitions_H), H }, // Zustand H
{ s_transitions_I, SIZE_OF(s_transitions_I), H } { s_transitions_I, SIZE_OF(s_transitions_I), H } // Zustand I
}; };
/* Definition der Ausgaenge */ /* Definition der Ausgaenge */
static const fsm_action_t s_out_table[NR_OF_STATES] = { static const fsm_action_t s_out_table[NR_OF_STATES] =
{
/* display muenz_rueck kaffee_los guthaben, display_string */ /* display muenz_rueck kaffee_los guthaben, display_string */
{ false, false, false, 0, "Warten" }, /* state A */ { false, false, false, 0, "Warten" }, /* state A */
{ false, false, false, 1, "1 Euro" }, /* state B */ { false, false, false, 1, "1 Euro" }, /* state B */
@ -117,48 +120,37 @@ static const fsm_action_t s_out_table[NR_OF_STATES] = {
{ true, false, true, 0, "Kaffe kommt" }, /* state H */ { true, false, true, 0, "Kaffe kommt" }, /* state H */
{ true, true, true, 0, "Kaffe kommt" } /* state I */ { true, true, true, 0, "Kaffe kommt" } /* state I */
}; };
/*--- Funktionsdefinition --------------------------------------------*/ /*--- Funktionsdefinition --------------------------------------------*/
/* Setzt den Automaten in den Startzustand zurück */
void automat_reset(void) void automat_reset(void)
{ {
printf("---- automat_reset ----\n"); printf("---- automat_reset ----\n"); // Ausgabe zur Kontrolle
s_curstate = A; s_curstate = A; // Automat in Startzustand (A) zurücksetzen
} }
/*--- Funktionsdefinition --------------------------------------------*/
/* Führt einen Zustandsübergang durch, basierend auf den Eingaben */
void automat_transition(BOOL becher, BOOL muenze, BOOL muenz_wert) void automat_transition(BOOL becher, BOOL muenze, BOOL muenz_wert)
{ {
printf("---- automat_transition becher(%0d) muenze(%0d) muenz_wert(%0d) ----\n", printf("---- automat_transition becher(%0d) muenze(%0d) muenz_wert(%0d) ----\n",
becher, muenze, muenz_wert); becher, muenze, muenz_wert); // Eingaben ausgeben
int in = (becher << 2) | (muenze << 1) | (muenz_wert << 0); // Eingabewert als Bitmuster kodieren
/* Eingabewert als Bitfeld kodieren: becher=Bit2, muenze=Bit1, muenz_wert=Bit0 */ const fsm_full_state_t * full_transition = &s_state_table[s_curstate]; // Übergangstabelle für aktuellen Zustand holen
int in = (becher << 2) | (muenze << 1) | (muenz_wert << 0); const fsm_state_t * transition = full_transition->transitions; // Zeiger auf Übergänge
const fsm_full_state_t * full_transition = &s_state_table[s_curstate];
const fsm_state_t * transition = full_transition->transitions;
int i; int i;
for(i = 0; i < full_transition->nrOfTransitions; i++) // Alle möglichen Übergänge prüfen
/* Übergänge prüfen */
for(i = 0; i < full_transition->nrOfTransitions; i++)
{ {
/* Maskenlogik: input == (in & mask) */ if(transition[i].input == (in & transition[i].mask)) // Prüfen, ob Eingabe zur Transition passt
if(transition[i].input == (in & transition[i].mask))
{ {
s_curstate = transition[i].nxtstate; s_curstate = transition[i].nxtstate; // In Zielzustand wechseln
break; break; // Schleife verlassen
} }
} }
/* Wenn kein Übergang passt, gehe in den Default-Zustand */ if(i == full_transition->nrOfTransitions) // Falls keine Transition gepasst hat
if(i == full_transition->nrOfTransitions)
{ {
s_curstate = full_transition->defaultNxtState; s_curstate = full_transition->defaultNxtState; // In Default-Zustand wechseln
} }
} }
/*--- Funktionsdefinition --------------------------------------------*/
/* Gibt die aktuellen Ausgänge des Automaten zurück */
fsm_action_t automat_output(void) fsm_action_t automat_output(void)
{ {
return s_out_table[s_curstate]; return s_out_table[s_curstate]; // Aktuelle Ausgabewerte für Zustand zurückgeben
} }
//gcc automat.c view.c main.c io.c checker.c -o console_automat //gcc automat.c view.c main.c io.c checker.c -o console_automat

67
dualrech.c
View File

@ -1,38 +1,83 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
/* Prüft, ob der übergebene String nur aus '0' und '1' besteht (also eine Dualzahl ist). Gibt 1 zurück, wenn ja, sonst 0.*/
int ist_dual(const char *s) { int ist_dual(const char *s) {
while (*s) if (*s != '0' && *s != '1') return 0; else s++; while (*s)
return 1; if (*s != '0' && *s != '1')
return 0; // Nicht erlaubt, also keine Dualzahl
else
s++; // Nächstes Zeichen prüfen
return 1; // Alles ok, Dualzahl
} }
/*Gibt die 32-Bit-Binärdarstellung einer Zahl aus. Es werden immer 32 Zeichen (Bits) ausgegeben, auch führende Nullen.*/
void print_bin(int n) { void print_bin(int n) {
for (int i = 31; i >= 0; i--) putchar((n >> i) & 1 ? '1' : '0'); for (int i = 31; i >= 0; i--)
putchar((n >> i) & 1 ? '1' : '0');
} }
/*
* Hauptprogramm: Erwartet 3 Argumente:
* 1. Operand (als Dualzahl, z.B. "1011")
* 2. Operator (als einzelnes Zeichen: + - * / & ^)
* 3. Operand (als Dualzahl)
* Führt die Operation aus und gibt das Ergebnis als Binärzahl und Hexadezimalzahl aus.
*/
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
// Prüfen, ob genau 3 Argumente übergeben wurden (Programmname + 3 = 4)
if (argc != 4) { if (argc != 4) {
printf("Richtiger Aufruf: %s <operand> <operator> <operand>\n", argv[0]); printf("Richtiger Aufruf: %s <operand> <operator> <operand>\n", argv[0]);
return 1; return 1;
} }
// Argumente zuweisen
char *a = argv[1], *op = argv[2], *b = argv[3]; char *a = argv[1], *op = argv[2], *b = argv[3];
int ok = 1; int ok = 1; // Flag, ob alles gültig ist
if (!ist_dual(a)) { printf("....... %s ist keine erlaubte Dualzahl\n", a); ok = 0; }
if (!ist_dual(b)) { printf("....... %s ist keine erlaubte Dualzahl\n", b); ok = 0; } // Prüfen, ob beide Operanden gültige Dualzahlen sind
if (strlen(op) != 1 || strchr("+-*/&^", op[0]) == NULL) { if (!ist_dual(a)) {
printf("....... %s ist kein erlaubter Operator\n", op); ok = 0; printf("....... %s ist keine erlaubte Dualzahl\n", a);
ok = 0;
} }
if (!ist_dual(b)) {
printf("....... %s ist keine erlaubte Dualzahl\n", b);
ok = 0;
}
// Prüfen, ob der Operator ein erlaubtes Zeichen ist
if (strlen(op) != 1 || strchr("+-*/&^", op[0]) == NULL) {
printf("....... %s ist kein erlaubter Operator\n", op);
ok = 0;
}
// Falls etwas ungültig war, Programm beenden
if (!ok) return 1; if (!ok) return 1;
// Dualzahlen in int umwandeln (Basis 2)
int x = strtol(a, NULL, 2), y = strtol(b, NULL, 2), r = 0; int x = strtol(a, NULL, 2), y = strtol(b, NULL, 2), r = 0;
if (*op == '/' && y == 0) { printf("Fehler: Division durch 0\n"); return 1; }
// Division durch 0 abfangen
if (*op == '/' && y == 0) {
printf("Fehler: Division durch 0\n");
return 1;
}
// Die gewünschte Operation ausführen
switch (*op) { switch (*op) {
case '+': r = x + y; break; case '+': r = x + y; break;
case '-': r = x - y; break; case '-': r = x - y; break;
case '*': r = x * y; break; case '*': r = x * y; break;
case '/': r = x / y; break; case '/': r = x / y; break;
case '&': r = x & y; break; case '&': r = x & y; break; // Bitweises UND
case '^': r = x ^ y; break; case '^': r = x ^ y; break; // Bitweises XOR
} }
// Ergebnis ausgeben: Eingabe, Operator, Ergebnis in Binär- und Hexadezimaldarstellung
printf("%s %s %s =\n....... ", a, op, b); printf("%s %s %s =\n....... ", a, op, b);
print_bin(r); print_bin(r);
printf(" (0x%X)\n", r); printf(" (0x%X)\n", r);
return 0; return 0;
} }

41
josephus.c
View File

@ -7,7 +7,7 @@
* *
\**********************************************************************/ \**********************************************************************/
/*--- #includes ------------------------------------------------------*/ /*--- #includes ------------------------------------------------------*/
#define _CRT_SECURE_NO_WARNINGS //VC++: keine scanf() Warnungen #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h> #include <stdio.h>
#include "queue.h" #include "queue.h"
/*--- #defines -------------------------------------------------------*/ /*--- #defines -------------------------------------------------------*/
@ -16,29 +16,32 @@
/*--- main -----------------------------------------------------------*/ /*--- main -----------------------------------------------------------*/
int main(void) int main(void)
{ {
int n, z, i=1, nr; int n, z, i=1, nr; // Variablen für Personenanzahl, Schrittweite, Zähler, Rückgabewert scanf
do { do {
printf("Wie viele Personen: "); printf("Wie viele Personen: "); // Benutzer nach Anzahl der Personen fragen
nr = scanf("%d", &n); getchar(); nr = scanf("%d", &n); getchar(); // Eingabe lesen, Rückgabewert speichern, Zeilenumbruch entfernen
} while (nr != 1 || n < 0); } while (nr != 1 || n < 0); // Wiederholen, falls ungültige Eingabe
do { do {
printf("Wie vielte ist auszusondern: "); printf("Wie vielte ist auszusondern: "); // Benutzer nach Schrittweite fragen
nr = scanf("%d", &z); getchar(); nr = scanf("%d", &z); getchar(); // Eingabe lesen, Rückgabewert speichern, Zeilenumbruch entfernen
} while (nr != 1 || z < 0); } while (nr != 1 || z < 0); // Wiederholen, falls ungültige Eingabe
for (i = 1; i <= n; i++) // Queue füllen
put(i); for (i = 1; i <= n; i++) // Queue füllen
while (!isEmpty()) { put(i); // Personen mit Nummer 1 bis n in die Queue einfügen
for (i = 1; i < z; i++) { // z-1 Zahlen aus Queue lesen
if (put(get()) == FALSE) { // und wieder am Ende der Queue einfügen while (!isEmpty()) { // Solange noch Personen in der Queue sind
fprintf(stderr, "Fehler beim Einfügen\n"); for (i = 1; i < z; i++) { // z-1 Personen überspringen
return 1; if (put(get()) == FALSE) { // Erste Person aus der Queue nehmen und wieder hinten einfügen
fprintf(stderr, "Fehler beim Einfügen\n"); // Fehlerausgabe, falls put fehlschlägt
return 1; // Programm mit Fehlercode beenden
} }
} }
printf("%d, ", get()); // z. Zahl aus Queue lesen und ausgeben printf("%d, ", get()); // Die z-te Person aus der Queue nehmen und ausgeben (ausscheiden)
// Diese Zahl nicht mehr einfügen // Diese Person wird nicht mehr eingefügt
} }
printf("\n"); printf("\n"); // Zeilenumbruch nach Ausgabe aller ausgeschiedenen Personen
return 0; return 0; // Programm erfolgreich beenden
} }
//gcc -c queue.c -o queue.o //gcc -c queue.c -o queue.o

25
numausg.c
View File

@ -1,21 +1,34 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
// Prüfen, ob ein Dateiname als Argument übergeben wurde
if (argc < 2) { if (argc < 2) {
printf("Bitte Dateinamen als erstes Argument angeben.\n"); printf("Bitte Dateinamen als erstes Argument angeben.\n");
return 1; return 1; // Fehlercode zurückgeben und Programm beenden
} }
// Datei im Lesemodus ("r") öffnen
FILE *datei = fopen(argv[1], "r"); FILE *datei = fopen(argv[1], "r");
if (datei == NULL) { if (datei == NULL) {
// Fehler beim Öffnen der Datei, z.B. Datei existiert nicht
perror("Fehler beim Öffnen der Datei"); perror("Fehler beim Öffnen der Datei");
return 1; return 1; // Fehlercode zurückgeben und Programm beenden
} }
char zeile[1024];
int zeilennummer = 1; char zeile[1024]; // Puffer für eine Zeile (max. 1023 Zeichen + '\0')
int zeilennummer = 1; // Startwert für die Zeilennummerierung
// Solange noch Zeilen gelesen werden können
while (fgets(zeile, sizeof(zeile), datei) != NULL) { while (fgets(zeile, sizeof(zeile), datei) != NULL) {
// Zeilennummer und Inhalt der Zeile ausgeben
// %4d: Zeilennummer rechtsbündig mit mindestens 4 Stellen
printf("%4d: %s", zeilennummer, zeile); printf("%4d: %s", zeilennummer, zeile);
zeilennummer++; zeilennummer++; // Zeilennummer erhöhen
} }
// Datei schließen
fclose(datei); fclose(datei);
return 0;
return 0; // Erfolgreiches Programmende
} }

55
queue.c
View File

@ -3,52 +3,85 @@
* queue.c - realisiert eine Queue (Warteschlange) * queue.c - realisiert eine Queue (Warteschlange)
* *
* Datum: Autor: * Datum: Autor:
* 11.06.2025 OpenAI (auf Basis von Prof. Herold) *
\**********************************************************************/ \**********************************************************************/
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "queue.h" #include "queue.h"
/*--- Struktur eines Listenelements ----------------------------------*/ /*--- Struktur eines Listenelements ----------------------------------*/
/*
* Ein Listenelement (Node) besteht aus:
* - value: dem gespeicherten Wert (hier ein int)
* - next: Zeiger auf das nächste Element in der Liste
*/
typedef struct Node { typedef struct Node {
int value; int value;
struct Node *next; struct Node *next;
} Node; } Node;
/*--- Modulglobale Variablen: Zeiger auf Kopf und Ende der Liste -----*/ /*--- Modulglobale Variablen: Zeiger auf Kopf und Ende der Liste -----*/
/*
* head: Zeigt auf das erste Element der Queue (Kopf)
* tail: Zeigt auf das letzte Element der Queue (Ende)
* Sind beide NULL, ist die Queue leer.
*/
static Node *head = NULL; static Node *head = NULL;
static Node *tail = NULL; static Node *tail = NULL;
/*--- put(): Einfügen am Ende der Liste ------------------------------*/ /*--- put(): Einfügen am Ende der Liste ------------------------------*/
/*
* Fügt eine neue Zahl am Ende der Queue ein.
* Rückgabewert: TRUE bei Erfolg, FALSE bei Speicherfehler.
*/
Bool put(int zahl) { Bool put(int zahl) {
// Speicher für neues Element reservieren
Node *newNode = (Node *)malloc(sizeof(Node)); Node *newNode = (Node *)malloc(sizeof(Node));
if (newNode == NULL) { if (newNode == NULL) {
fprintf(stderr, "Speicher konnte nicht allokiert werden.\n"); fprintf(stderr, "Speicher konnte nicht allokiert werden.\n");
return FALSE; return FALSE; // Fehler: kein Speicher verfügbar
} }
newNode->value = zahl; newNode->value = zahl; // Wert setzen
newNode->next = NULL; newNode->next = NULL; // Am Ende zeigt next auf NULL
if (tail != NULL) { if (tail != NULL) {
// Es gibt schon Elemente: neues Element ans Ende anhängen
tail->next = newNode; tail->next = newNode;
} else { } else {
head = newNode; // Liste war leer // Die Liste war leer: head zeigt jetzt auf das neue Element
head = newNode;
} }
// tail zeigt immer auf das letzte Element
tail = newNode; tail = newNode;
return TRUE; return TRUE;
} }
/*--- get(): Entfernt das erste Element ------------------------------*/ /*--- get(): Entfernt das erste Element ------------------------------*/
/*
* Entfernt das erste Element (Kopf) der Queue und gibt dessen Wert zurück.
* Ist die Queue leer, wird QLEER zurückgegeben und eine Fehlermeldung ausgegeben.
*/
int get(void) { int get(void) {
if (head == NULL) { if (head == NULL) {
// Die Queue ist leer
fprintf(stderr, "Fehler: Queue ist leer.\n"); fprintf(stderr, "Fehler: Queue ist leer.\n");
return QLEER; return QLEER;
} }
Node *tmp = head; Node *tmp = head; // Temporärer Zeiger auf das erste Element
int value = tmp->value; int value = tmp->value; // Wert des ersten Elements speichern
head = head->next; head = head->next; // Kopf auf das nächste Element setzen
if (head == NULL) { if (head == NULL) {
tail = NULL; // Liste ist jetzt leer // Nach dem Entfernen ist die Queue leer, also tail auch auf NULL setzen
tail = NULL;
} }
free(tmp); free(tmp); // Speicher des entfernten Elements freigeben
return value; return value; // Wert zurückgeben
} }
/*--- isEmpty(): Prüft, ob Liste leer ist ----------------------------*/ /*--- isEmpty(): Prüft, ob Liste leer ist ----------------------------*/
/*
* Gibt TRUE zurück, wenn die Queue leer ist, sonst FALSE.
*/
Bool isEmpty(void) { Bool isEmpty(void) {
return head == NULL ? TRUE : FALSE; return head == NULL ? TRUE : FALSE;
} }