Bild Referenz: 
Intro
Hallo, ich bin's @drifter2! Der heutige Artikel ist wieder mal eine Übungsaufgabe rund um Stapel und Warteschlangen, die dieses mal an meinem englischen Artikel "C Stack-Queue Exercise using Linked Lists" basiert ist. Letztes mal hatten wir was sehr ähnliches mit Dynamischen Feldern implementiert. Natürlich solltet ihr euch erstmal die Artikel rund um Stapel und Warteschlangen anschauen, und vielleicht auch die vorherige Übungsaufgabe. Also dann fangen wir dann mal direkt an!
Aufgabenbeschreibung:
Ähnlich wie beider vorherigen Aufgabe haben wir wieder mal 2 Fähren Boote. Die erste Fähre heißt 'S', weil sie wie eine Stapel (Stack auf Englisch) funktioniert. Die zweite 'Q', weil sie wie eine Warteschlange (Queue auf Englisch) funktioniert. Diese Funktionalität zeigt uns in welcher Reihenfolge Autos in diese Fähren reingesetzt und wieder weggenommen werden können. Jedes Auto wird jetzt aber nicht mehr eine Fähre auswählen, sondern die Autos werden erstmal in Fähre S und dann in Fähre Q eingefügt.
Der Dateiname ist eine Eingabe des Benutzers des Programms und muss die Auto-ID (Identifikationsnummer oder auch Nummernschild) enthalten. Damit wir die Resultate mit denen vom letztem mal vergleichen können, werden wir wieder in der Datei immer noch eine Boot-Präferenz abspeichern, die bei dieser Aufgabe hier eigentlich unnötig ist. Eine solche Datei die 5 Autos mit dessen Präferenz enthält kann wie folgend aussehen:
ZZA9896 S
MIN5689 Q
NHI9098 S
KNM4545 Q
IPO8987 Q
Das Programm das ihr implementiert muss folgendes machen:
- Die Kapazität der Boote und den Namen der Autos-Datei als Eingabe des Benutzers bekommen
- Die Boote, oder besser gesagt, dessen Datenstrukturen, initialisieren
- Von der Autos-Datei lesen und das Segeln beider Boote verwalten, indem man diese füllt bis sie voll sind
- Die Autos gehen erstmal in Boot S. Wenn diese Boot voll wird, dann fangen wir mit dem "Segeln" an, welches bedeutet das wir die Auto-ID's in einer Neuen Datei schreiben und das natürlich per Segel, indem wir den Stapel entleeren. Die Namen dieser Dateien sollten in der Form: s0, s1, s2, ... sein
- Bei dem entleeren von Boot S werden die Autos dann in Boot Q eingefügt und das bis S leer ist (das sollte natürlich vor dem Segeln von S anfangen!). Jedes mal wenn Q voll wird werden wir wieder mal mit dem "Segeln" anfangen, indem wir die Auto-ID's in einer neuen Datei schreiben, mit Namen der Form: qo, q1, q2, ... per Segel.
- Die Schritte 3-5 werden wiederholt bis kein neues Auto in der Autos-Datei ist (EOF)
- Danach müssen wir nochmals kontrollieren ob es Autos in den Booten gibt, welches bedeutet das wir auch die "nicht-vollen" Segel ausführen, indem wir auch diese normal in Dateien schreiben. Natürlich sollten wir hier aufpassen das die Autos wiedermal erstmal in S reingehen und danach in Q!
Die eigentliche Veränderung ist also bei Schritt 4 (der jetzt in 4 und 5 eingeteilt wurde)
Die Stapel und Warteschlangen Operationen müssen als Funktionen implementiert werden.
Lösung-Implementation in C
Datenstrukturen
Da wir über Listen reden müssen wir natürlich einen Knoten (Node) definieren welcher eine Auto-ID und einen Zeiger auf den nächsten (next) Knoten enthält. Die Struktur des Knoten sieht also wie folgend aus:
typedef struct Node{ char car_id[10]; struct Node *next;}Node;Ich sollte hier vielleicht mal erwähnen das wir von der Autos-Datei wissen das die Auto-ID's aus 7 Zeichen bestehen. Das heißt also das diese als Zeichenkette ein 8er Feld brauchen (\0 am Ende). Wie ihr sehen könnt ist die maximale Länger aber ein wenig höher, so das ich eine "vollere" Nummer habe :P
Die Boot-Strukturen müssen folgendes enthalten:
- eine gewisse Kapazität (capacity auf Englisch) Variable so das wir kontrollieren ob Boot voll ist oder auch leer für Schritt 7
- eine Segel Nummer (sailing number auf Englisch) um die richtige Nummer bei den Dateinamen zu verwenden
- Die Anzahl an Elementen die eingefügt wurden (numElements)
- Top-Zeiger für den Stapel und Front und Rear-Zeiger für die Warteschlange
Die Strukturen (structs) sehen also in Code wie folgend aus:
// Stapel Strukturtypedef struct Stack{ int sail_num; int capacity; int numElements; Node *Top;}Stack;// Warteschlangen Strukturtypedef struct Queue{ int sail_num; int capacity; int numElements; Node *front; Node *rear; }Queue;Wie ihr sehen könnt ist diese Definition nicht so ganz abweichend von der die wir bei den Artikeln erwähnt haben. Wir haben einfach ein paar Variablen ergänzt die bei der Anwendung hilfreich sind. Fangen wir dann mal mit der Implementierung von den verschiedenen Funktionen und Schritten an...
Benutzer-Eingabe und Lesen der Autos-Datei
Wie beim letzen mal werden wir die Struktur-Variablen wieder mal "ganz normal" und nicht als Zeiger definieren wie folgend:
Stack S;Queue Q;Die Kapazität kann dann sehr leicht wie folgend als Eingabe genommen werden:
printf("Capacity of S: "); scanf("%d", &S.capacity);printf("Capacity of Q: ");scanf("%d", &Q.capacity);Um von einer Datei lesen zu können brauchen wir erstmals einen Datei-Zeiger (file pointer - fp auf Englisch). Zusätzlich werden auch temporäre Lese-Puffer gebraucht für die Auto-ID und die Boot-Präferenz (auch wenn diese nur gebraucht wird um beim Motiv der Datei zu bleiben). Natürlich sollten wir auch nicht vergessen eine Zeichenkette für den eigentlichen Dateinamen zu definieren.
Also brauchen wir:
char input_file[20]; // DateinameFILE *fp; // Datei Zeiger// Lese-Puffer fuer die Dateichar car_id[10];char ship;Der Dateiname kann sehr leicht genommen werden:
printf("Input File: ");scanf("%19s", input_file);Das öffnen der Datei zum Lesen sieht wie folgend aus:
if(!(fp=fopen(input_file, "r"))){ perror("fopen"); return 1;} Wir kontrollieren natürlich auch ob es vielleicht einen Datei-Fehler gab, da sonst die Programmausführung nicht weitergehen kann. Die Datei könnte z.B nicht existieren oder der Zugriff könnte verweigert sein.
Datenstrukturen initialisieren
Um den Stapel zu initialisieren müssen wir folgendes machen:
- Den Top-Zeiger auf NULL initialisieren
- Nummer von Elementen (numElements) auf '0' setzen
- Segelnummer auf '0' setzen
Das ganze sieht in Code wie folgend aus:
S.Top=NULL;S.numElements=0;S.sail_num=0;Da bei Listen kein Speicher zugewiesen werden muss und das automatisch bei der Ausfuhr passiert, ist die Initialisierung beider Strukturen sehr simple gehalten!
Die Warteschlange wird wie folgend initialisiert:
- Front und Rear-Zeiger auf NULL initialisieren
- Nummer von Elementen (numElements) auf '0' setzen
- Segelnummer auf '0' setzen
Der eigentliche Code sieht wie folgend aus:
Q.front=Q.rear=NULL;Q.numElements=0;Q.sail_num=0;Sehr ähnlich mit der Stapel-Initialisierung.
Datenstruktur-Operationen
Bevor wir weitermachen sollten wir jetzt die eigentlichen Funktionen für die Verwaltung der Boot-Strukturen implementieren, damit wir diese dann direkt bei der Lesungs-While-Schleife verwenden können...
Die Funktionen-Operationen die wir brauchen sind:
- Auto-ID in Stapel einfügen (push)
- Auto-ID vom Stapel rausnehmen (pop)
- Stapel in Datei einspeichern - Segeln von 'S' ausführen (StackToFile)
- Auto-ID in Warteschlange einfügen (add)
- Auto-ID von der Warteschlange rausnehmen (delete)
- Warteschlange in Datei einspeichern - Segeln von 'Q' ausführen (QueueToFile)
Implementieren wir mal jede alleine...
In Stapel einfügen
Beim einfügen müssen wir erstmal einen neuen Knoten erstellen. Danach kontrollieren wir erstmal ob der Stapel leer ist. Wenn ja dann wird das neue Element der neue Kopf der Liste, wenn nicht dann wird dieser wieder der neue Kopf der Liste aber zusätzlich die vorherige Liste sein next-Zeiger. Bei beiden Fällen inkrementieren wir auch die Anzahl an Elementen um zu wissen wann der Stapel voll ist. Wir ihr bereites verstehen könnt kontrollieren wir hier nirgends ob der Stapel voll ist, da das bei der main() Funktion bereits kontrolliert wird, so das die Entleerung erst nach dem Segeln von Boot Q stattfindet.
Das sieht in Code wie folgend aus:
void push(Stack *S, char x[]){ Node *cur, *nn; // neuen Knoten erstellen nn=(Node*)malloc(sizeof(Node)); strcpy(nn->car_id, x); nn->next=NULL; // wenn leer ist der der neue Kopf if(S->Top==NULL){ S->Top=nn; S->numElements++; return; } // wenn bereits Elemente da sind, wird der next-Zeiger // von "nn" auf diese zeigen und dann der neue Kopf werden if(S->numElements < S->capacity){ nn->next=S->Top; S->Top=nn; S->numElements++; } // Wir koennten beides auch direkt vom Zweiten "if" machen // da ja der Top-Zeiger beim ersten mal sowieso NULL waehre!}Vom Stapel rausnehmen
Beim rausnehmen kontrollieren wir erstmal ob der Stapel vielleicht leer ist. Das geht ganz leicht indem wir abchecken ob der Wert vom Top-Zeiger 'NULL' ist. Wenn nicht leer speichern wir den Wert im zweiten Parameter ab und lassen Top-Zeiger auf seinen "next" zeigen, so das wir im Stapel weitergehen!
Das ganze sieht in Code wie folgend aus:
void pop(Stack *S, char *car_id){ // kontrollieren ob Stapel leer ist (unnoetig) if(S->Top==NULL){ printf("Stack is empty!\n"); } // Wert in Parameter speichern und dann Top-Zeiger // auf den naechsten (next) Knoten zeigen lassen else{ strcpy(car_id, S->Top->car_id); S->Top=S->Top->next; }}Stapel Segeln ausführen
Beim Segeln müssen wir natürlich erstmal den Dateinamen "erschaffen". Das kann leicht mit Hilfe von den Funktionen:
- itoa(), welche eine Funktion ist die Ganzzahlen in Zeichenketten konvertiert
- strcpy(), welche eine Funktion ist die eine Zeichenkette kopiert (copy)
- strcat(), welche eine Funktion ist die Zeichenketten "verkettet" (concatenate)
gemacht werden.
Natürlich werden wir dann eine Datei zum schreiben öffnen die diesen Namen hat und dann mit einer While-Schleifen so lange von dem Stapel rausnehmen mit pop() und schreiben bis der Top-Zeiger einen Wert von "NULL" hat. Wie ihr sehen könnt kann man damit sehr leicht kontrollieren ob der Stapel voll ist, etwas das hier sonst nicht ging, da wir nicht den Wert zurückgeben, da dieser ja keine Nummer ist. Man könnte eine gewisse Auto-ID als "Leer-Zeichen" benutzen aber ich glaub das ist hier eh unnötig. Damit die Daten vom Stapel nicht verloren gehen und dann von der Warteschlange benutzbar sind geben wir die Struktur diesem mal als Variable und nicht als Zeiger ein! Die erneute Initialisierung wir erst später von der main() Funktion kontrolliert!
Der Code sieht wie folgend aus:
void StacktoFile(Stack S){ FILE *fp; Node *cur; char output_file[10]; char buffer[2]; char car_id[10]; itoa(S.sail_num, buffer, 10); strcpy(output_file, "s"); strcat(output_file, buffer); strcat(output_file, ".txt"); fp=fopen(output_file, "w"); while(S.Top!=NULL){ pop(&S, car_id); fprintf(fp, "%s\n", car_id); } fclose(fp);}Das einzige neue ist also eigentlich nur das wir den Top-Zeiger nun mit NULL anstatt '-1' vergleichen, etwas das beim Top-Index verwendet wurden.
In Warteschlange einfügen
Um eine Auto-ID in die Warteschlange einzufügen müssen wir erstmal wieder mal einen neuen Knoten erstellen. Danach gibt es 3 gewisse Fälle die wir kontrollieren sollten. Wenn Liste/Warteschlange leer ist dann werden beider Zeiger (Front und Rear) mit "nn" gleichgesetzt. Wenn bereits Elemente da sind, iterieren wir durch die Liste mit einen Jetzige-Knote-Zeiger (cur pointer) und fügen das neue Element (den neuen Knoten) am Ende ein. Bei beiden Fällen sollten wir die Nummer von Elementen inkrementieren. Der letzte Fall den wir kontrollieren sollten ist ob die Warteschlange voll ist. Wenn voll führen wir das Segeln aus, im Gegensatz zum "darf" man das hier machen, da ja die Warteschlange von keinem "folgenden" Boot benutzt wird.
Der Code ist wie folgend:
void add(Queue *Q, char x[]){ Node *cur, *nn; // neuen Knoten erstellen nn=(Node*)malloc(sizeof(Node)); strcpy(nn->car_id, x); nn->next=NULL; // wenn leer ist wird "nn" neuer Front- und Rear-Zeiger if(Q->front == NULL){ Q->front=Q->rear=nn; Q->numElements++; } // wenn Elemente da wird "nn" am Ende eingefuegt if(Q->numElements<Q->capacity){ cur=Q->front; while(cur->next!=NULL){ cur=cur->next; } cur->next=nn; Q->rear=nn; Q->numElements++; } // wenn voll dann wird Segeln ausgefuehrt else{ QueuetoFile(Q); }}Von der Warteschlange rausnehmen
Beim rausnehmen können wir wieder mal kontrollieren ob die Warteschlange vielleicht leer ist, etwas das aber wieder mal von dem Segeln kontrolliert werden kann. Danach gibt es zwei Fälle: das zulöschende Element ist das einzige Element oder es gibt mehrere. Beim ersten Fall müssen wir beide Zeiger auf 'NULL' initialisieren. Beim zweiten nur Front-Zeiger zum seinen nächsten Knoten zeigen lassen. Bei beiden sollten wir den Wert wieder mal beim zweiten Parameter abspeichern.
Der Code dafür ist:
void delete(Queue *Q, char *car_id){ // kontrollieren ob leer ist (unnoetig) if(Q->front==NULL){ printf("Queue is Empty!\n"); } else{ // einziges Element - beides wird 'NULL' if(Q->front==Q->rear){ strcpy(car_id, Q->front->car_id); Q->front=Q->rear=NULL; Q->numElements=0; } // es gibt noch andere Elemente - Front Zeiger -> next else{ strcpy(car_id, Q->front->car_id); Q->front=Q->front->next; Q->numElements--; } }}Warteschlange Segeln ausführen
Ähnlich wie beim Stapel müssen wir erstmal den Dateinamen "erschaffen". Danach können wir ganz normal eine Datei mit diesen Dateinamen zum schreiben öffnen und mit einer While-Schleife ganz normal die Auto-ID's rausnehmen und schreiben, solange die Warteschlange nicht leer ist. Zuletzt sollten wir die Warteschlange erneut initialisieren, indem wir erstmals die Segelnummer inkrementieren und die Nummer der Elemente auf '0' setzen.
Der Code ist also:
void QueuetoFile(Queue *Q){ Node *cur; FILE*fp; int i; char output_file[10]; char buffer[2]; char car_id[10]; itoa(Q->sail_num, buffer, 10); strcpy(output_file, "q"); strcat(output_file, buffer); strcat(output_file, ".txt"); fp=fopen(output_file, "w"); while(Q->front!=NULL){ delete(Q, car_id); fprintf(fp, "%s\n", car_id); } Q->sail_num++; Q->numElements=0; fclose(fp);}Lese-Schleife
Das Lesen geht mit einer While-Schleife, welche aufhört wenn es in der Datei keine Elemente (Auto-ID's) mehr gibt, also solange mann nicht das Ende der Datei (EOF) erreicht hat. Bei dieser Kontrolle lesen wir natürlich auch immer die Auto-ID und die Boot-Präferenz, auch wenn die zweite hier nicht gebraucht wird und nur benutzt wir um die gleiche Datei verwenden zu können. Danach fügen wir die jetzige Auto-ID bei Boot 'S' ein. Dabei kontrollieren wir ob das Boot voll ist. Wenn voll führen wir erstmal das Segeln aus, womit aber die Daten des Stapel nie verloren gehen, da wir ja nur die Struktur-Daten abgeben und nie die eigentliche Adresse dieser Daten! Danach iterieren wir durch den Stapel und fügen die Auto-ID's in der Warteschlange ein, solange wir nicht das Ende des Stapels erreicht haben. Jedes mal wo die Warteschlange voll wird müssen wir ein Segeln von Boot Q ausführen. Nachdem alle Elemente von dem Stapel durch-iteriert wurden inkrementieren wir die Segelnummer vom Stapel und setzen diesen zurück, indem wir Top-Zeiger wieder auf 'NULL' initialisieren und die Nummer der Elemente auf '0' setzen (indem wir also alles was nicht bei der Funktion StacktoFile() ausgeführt wurde nun ausführen).
Der Code sieht wie folgend aus:
// solange wir nicht das Ende der Datei (EOF) erreicht habenwhile(fscanf(fp, "%9s %c", car_id, &ship)!=EOF){ // Auto-ID in Stapel einfuegen push(&S, car_id); // wenn Stapel voll wird in Datei schreiben if(S.numElements==S.capacity){ StacktoFile(S); // in naechste Faehre (Q) einfuegen cur=S.Top; while(cur!=NULL){ // Auto-ID in Warteschlange einfuegen add(&Q, cur->car_id); // wenn voll in Datei schreiben if(Q.numElements==Q.capacity){ QueuetoFile(&Q); } cur=cur->next; } // Stapel zuruecksetzen S.sail_num++; S.Top=NULL; S.numElements=0; } }Kontrollieren ob Boote (wirklich) leer sind
Nach dieser Schleife sollten wir nochmal kontrollieren ob es noch Autos (oder Auto-ID's) in den Booten gibt, da unser Code ja nur einschreibt wenn die maximale Kapazität erreicht wurde. Das kann man sehr leicht machen indem man sich die "numElements" Variablen anschaut. Wenn diese nicht '0' sind dann heißt "Mann über Bord"! Wir sollten dabei natürlich aufpassen das wir S entleeren und dabei Q füllen. Nachdem S fertig ist kann es natürlich immer noch sein das Boot Q immernoch Autos enthält, also kontrollieren wir danach auch noch Boot Q alleine! Danach noch die Datei schließen und das war's...
Der Code ist:
// kontrollieren ob S noch Autos hatif(S.numElements!=0){ StacktoFile(S); // in naechste Faehre (Q) einfuegen cur=S.Top; while(cur!=NULL){ add(&Q,cur->car_id); // wenn voll Q in Datei schreiben if(Q.numElements!=0){ QueuetoFile(&Q); } cur=cur->next; }}// kontrollieren ob Q noch Autos hatif(Q.numElements!=0) QueuetoFile(&Q);fclose(fp);return 0; Das vollständige Programm:
Hier noch mal das komplette Programm...
#include <stdio.h>#include <stdlib.h>#include <string.h>// Knoten Struktur fuer die Listentypedef struct Node{ char car_id[10]; struct Node *next;}Node;// Stapel Struktur typedef struct Stack{ int sail_num; int capacity; int numElements; Node *Top;}Stack;// Warteschlangen Struktur typedef struct Queue{ int sail_num; int capacity; int numElements; Node *front; Node *rear; }Queue;// Funktionen Deklarieren void push(Stack *S, char *x);void pop(Stack *S, char *car_id); void StacktoFile(Stack S);void add(Queue *Q, char *x);void delete(Queue *Q, char *car_id);void QueuetoFile(Queue *Q);int main(){ // Boot Variablen Stack S; Queue Q; // Hilfs-Variablen Node *cur; char input_file[20]; int i; FILE *fp; // Temporaere Datei-Puffer char car_id[10]; char ship; // Kapazitaet Eingabe printf("Capacity of S: "); scanf("%d", &S.capacity); printf("Capacity of Q: "); scanf("%d", &Q.capacity); // Dateinamen Eingabe printf("Input File: "); scanf("%19s", input_file); // Datei zum lesen oeffnen if(!(fp=fopen(input_file, "r"))){ perror("fopen"); return 1; } // Stapel initialisieren S.Top=NULL; S.numElements=0; S.sail_num=0; // Warteschlange initialisieren Q.front=Q.rear=NULL; Q.numElements=0; Q.sail_num=0; // solange wir nicht das Ende der Datei (EOF) erreicht haben while(fscanf(fp, "%9s %c", car_id, &ship)!=EOF){ // Auto-ID in S einfuegen push(&S, car_id); // wenn voll in Datei schreiben if(S.numElements==S.capacity){ StacktoFile(S); // in naechste Faehre (Q) einfuegen cur=S.Top; while(cur!=NULL){ // Auto-ID in Q einfuegen add(&Q, cur->car_id); // wenn voll in Datei schreiben if(Q.numElements==Q.capacity){ QueuetoFile(&Q); } cur=cur->next; } // Stapel zuruecksetzen S.sail_num++; S.Top=NULL; S.numElements=0; } } // kontrollieren ob S noch Autos hat if(S.numElements!=0){ StacktoFile(S); // in naechste Faehre (Q) einfuegen cur=S.Top; while(cur!=NULL){ add(&Q,cur->car_id); // wenn voll Q in Datei schreiben if(Q.numElements!=0){ QueuetoFile(&Q); } cur=cur->next; } } // kontrollieren ob Q noch Autos hat if(Q.numElements!=0) QueuetoFile(&Q); fclose(fp); return 0; }// Stapel Funktionen void push(Stack *S, char x[]){ Node *cur, *nn; nn=(Node*)malloc(sizeof(Node)); strcpy(nn->car_id, x); nn->next=NULL; if(S->Top==NULL){ S->Top=nn; S->numElements++; return; } if(S->numElements < S->capacity){ nn->next=S->Top; S->Top=nn; S->numElements++; }}void pop(Stack *S, char *car_id){ if(S->Top==NULL){ printf("Stack is empty!\n"); } else{ strcpy(car_id, S->Top->car_id); S->Top=S->Top->next; }}void StacktoFile(Stack S){ FILE *fp; Node *cur; char output_file[10]; char buffer[2]; char car_id[10]; itoa(S.sail_num, buffer, 10); strcpy(output_file, "s"); strcat(output_file, buffer); strcat(output_file, ".txt"); fp=fopen(output_file, "w"); while(S.Top!=NULL){ pop(&S, car_id); fprintf(fp, "%s\n", car_id); } fclose(fp);}// Warteschlangen Funktionen void add(Queue *Q, char x[]){ Node *cur, *nn; nn=(Node*)malloc(sizeof(Node)); strcpy(nn->car_id, x); nn->next=NULL; if(Q->front == NULL){ Q->front=Q->rear=nn; Q->numElements++; } if(Q->numElements<Q->capacity){ cur=Q->front; while(cur->next!=NULL){ cur=cur->next; } cur->next=nn; Q->rear=nn; Q->numElements++; } else{ QueuetoFile(Q); }}void delete(Queue *Q, char *car_id){ if(Q->front==NULL){ printf("Queue is Empty!\n"); } else{ if(Q->front==Q->rear){ strcpy(car_id, Q->front->car_id); Q->front=Q->rear=NULL; Q->numElements=0; } else{ strcpy(car_id, Q->front->car_id); Q->front=Q->front->next; Q->numElements--; } }}void QueuetoFile(Queue *Q){ Node *cur; FILE*fp; int i; char output_file[10]; char buffer[2]; char car_id[10]; itoa(Q->sail_num, buffer, 10); strcpy(output_file, "q"); strcat(output_file, buffer); strcat(output_file, ".txt"); fp=fopen(output_file, "w"); while(Q->front!=NULL){ delete(Q, car_id); fprintf(fp, "%s\n", car_id); } Q->sail_num++; Q->numElements=0; fclose(fp);}Ausführungsbeispiel
Sagen wir mal wir geben (wieder) folgendes ein:
- Kapazität für S : 2
- Kapazität für Q : 1
- Autos-Datei mit namen "cars.txt" und den vorherigen 5 AutoID-Präferenz Paaren
Diese Ausführung würde folgende Dateien erzeugen:
s0.txt
MIN5689
ZZA9896
q0.txt
MIN5689
q1.txt
ZZA9896
s1.txt
KNM4545
NHI9098
q2.txt
KNM4545
q3.txt
NHI9098
s2.txt
IPO8987
q4.txt
IPO8987
Damit ihr besser versteht was hier abgeht habe ich die Segel mit s-q Paaren geschrieben. Ihr könnt damit sehen wie S voll wird und dann seine Daten in Q eingeschrieben werden. Beim letzten mal reichen die Auto-ID's der Datei ja nicht aus um den Stapel voll zu machen, also sieht man wieso die Kontrolle nach der eigentlichen Lese-Schleife so wichtig ist! Die Kontrolle von Boot Q wird hier nicht verwendet da das Boot ja bereits bei dem Segeln von S voll wurde und somit ein Segeln ausgeführt wird. Diese letzte Kontrolle ist also nur von Nöten wenn S kleiner ist als Q (in Kapazität). Damit ihr die eigentliche Ausführungsreihenfolge besser versteht, solltet ihr diesen Code vielleicht auch selber mal ausführen! Aber ich glaub ich hab alles generell sehr gut und sehr präzise erklärt!
Referenzen:
Ja nur dieser "kleine" Englische Artikel...aber ich habe trotzdem versucht alles viel kompletter gestaltet als davor, da ich dort ja nur eine Beschreibung und dann den kompletten Code gegeben hatte!
Vorherige Artikel
Grundlagen
Einführung -> Programmiersprachen, die Sprache C, Anfänger Programme
Felder -> Felder, Felder in C, Erweiterung des Anfänger Programms
Zeiger, Zeichenketten und Dateien -> Zeiger, Zeichenketten, Dateiverarbeitung, Beispielprogramm
Dynamische Speicherzuordnung -> Dynamischer Speicher, Speicherzuweisung in C, Beispielprogramm
Strukturen und Switch Case -> Switch Case Anweisung, Strukturen, Beispielprogramm
Funktionen und Variable-Gueltigkeitsbereich -> Funktionen, Variable Gueltigkeitsbereich
Datenstrukturen
Rekursive Algorithmen -> Rekursion, Rekursion in C, Algorithmen Beispiele
Verkettete Listen -> Datenstrukturen generell Verkettete Liste, Implementation in C (mit Operationen/Funktionen), komplettes Beispielprogramm
Binäre Suchbäume -> Baum Datenstruktur generell, Binärer Baum, Binärer Suchbaum, Implementation in C-Sprache (mit Operationen/Funktionen), komplettes Beispielprogramm
Warteschlangen implementiert mit Feldern -> Warteschlange als Datenstruktur, Implementation einer Warteschlange mit Feldern in C-Sprache, komplettes Beispielprogramm
Stapel implementiert mit Feldern -> Stapel als Datenstruktur, Implementation eines Stapels mit Feldern in C-Sprache, komplettes Beispielprogramm
Warteschlangen und Stapel implementiert mit Verketteten Listen -> Liste, Warteschlange und Stapel mit Liste implementieren in C-Sprache.
Fortgeschrittene Listen und Warteschlangen -> Doppelt verkettete Listen (mit Implementation), Zirkuläre Listen, Vorrangwarteschlange (mit Implementation)
Fortgeschrittene Bäume -> Βinärer Suchbaum (Zusammenfassung), AVL-Baum (mit Implementation), Rot-Schwarz (ohne Code) und 2-3-4 Bäume (ohne Code)
Stapel-Warteschlangen Übungsaufgabe mit Dynamischen Feldern -> Aufgabenbeschreibung, Lösung-Implementation in C (zutiefst) und Vollständiges Programm mit Ausführungsbeispiel
Schlusswort
Und das war's dann auch schon mit dem heutigen Artikel und ich hoffe euch hat dieser Artikel gefallen. Der nächste Artikel der Serie wird über die Vergleichung von Funktionen reden, wo wir dazu die Ausführungszeit und auch Iteration-Schritte verwenden werden. Das wird euch sehr dabei helfen die effizienteste Lösung zu finden wenn ihr einen Algorithmus oder generell die Implementation in Code optimieren wollt.
Keep on drifting! ;)