Program: ma3

MA3/josephus.c

@@ -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
+}

MA3/queue.c

@@ -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;
+   }
+}

MA3/queue.h

@@ -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*/