Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Liste nach dem Fifo Prinzip in reinem C

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
23.11.2003, 19:21 Uhr
audaxx



Hi !!
In dem letzten Teil meiner Ausbildung beschäftigen wir uns mit einfach und auch doppelt verketteten Listen in C, mit denen allle so ihre Probs haben (mich eingeschlossen)..Wir haben zunächst ein Menue gebastelt, welches sich Daten aus einer Textdatei zieht, wenn man über die M-Punkte läuft. Dieses basierte auf einem struct. Das ging noch einigermaßen (habs hinbekommen )
Jedoch erweiterten wir jetzt das ganze um folgende Liste nach dem LIFO Prinzip

C++:
#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <stdlib.h>


struct Satz  {
           char Name[16];
           char Symbol [3];
           float Dichte;
           float Cellsius;
           int Xkor;
           int Ykor;

struct Satz *next;

         };


void dummy();
int lesen (FILE*,struct Satz*);
void ausgeben (struct Satz*);
void einfuegen(struct Satz **Anker,struct Satz Daten);

void main ()

{

int i;

struct Satz Daten,*Anker=NULL;
FILE *fp;

if ((fp = fopen ("daten.txt","r"))==NULL)
     {
       fprintf(stderr,"Misstake during opening the file \n ");
       exit(666);
     }

  clrscr();
  while (lesen(fp,&Daten)!=EOF)
     einfuegen(&Anker,Daten);
     ausgeben(Anker);

}


void dummy()
{
  float x;
  scanf("%f",&x);
}


int lesen (FILE *pf,struct Satz*pD)
{
  if (fscanf(pf,"%s",pD -> Name)==EOF) return EOF;


      fscanf(pf,"%s", pD -> Symbol);
      fscanf(pf,"%f",&pD -> Dichte);
      fscanf(pf,"%f",&pD -> Cellsius);
      fscanf(pf,"%d",&pD -> Xkor);
      fscanf(pf,"%d",&pD -> Ykor);

}

void ausgeben (struct Satz *pD)

{

  while (pD!=NULL)

   {
    printf("%s\n",pD -> Name);   // eigentlich (*pD).Name
    pD = pD -> next;             // eigentlich (*pD).next
   }

}

void einfuegen(struct Satz **Anker,struct Satz Daten)
{

  struct Satz *hilf = *Anker;
  *Anker=(struct Satz*)malloc(sizeof(struct Satz));
  **Anker=Daten;
  (*Anker) -> next = hilf;

}



Die Funktion dummy ist nötig, um einen bug im Borland Compiler zu denzimieren ;-)

Kann mir jemand bei dem FIFO Prinzip helfen ? Und wie läuft man vor und zurück; was sind doppelt verkettete Listen? Führt das zu den besagten Binären Bäumen ? Fragen über Fragen..
Please help me a bit...

--edit: Pablo. [ cpp ] tags gesetzt. Bitte nächstes Mal daran denken!--

Dieser Post wurde am 23.11.2003 um 19:25 Uhr von Pablo Yanez Trujillo editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
23.11.2003, 19:38 Uhr
Pablo
Supertux
(Operator)


ok, 1. main funktion ist int, nicht void
2. FIFO=FirstIn, FirstOut

Was du machen kannst ist stest einen Pointer auf den Kopf der Liste, das erste Element. Wenn du etwas löschen willst, dann setzt du diesen Pointer auf das nächste Element, welches als neuer Kopf der Liste dienen soll und löscht das alte erste Element.


C++:
void delete(struct Satz **Anker)
{
    struct Satz* tmp;
    if(Anker==NULL || *Anker==NULL) return;
    if(Anker->next == NULL) {
        // lieste leer
        Anker = NULL;
        return;
    }
    tmp = *Anker;
    Anker = (*Anker)->next;
    free(tmp);
}


Somit zeigt der Kopf von Anker auf das nächste Element.


Bearbeitung:

Dein Code hat Speicherlecks, denn du gibst den Speicher von malloc nicht frei. IMMER free benutzen, wenn man malloc benutzt hat.


--
A! Elbereth Gilthoniel!
silivren penna míriel
o menel aglar elenath,
Gilthoniel, A! Elbereth!

Dieser Post wurde am 23.11.2003 um 19:40 Uhr von Pablo Yanez Trujillo editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
24.11.2003, 09:28 Uhr
ao

(Operator)



Zitat:
audaxx postete
Kann mir jemand bei dem FIFO Prinzip helfen ? Und wie läuft man vor und zurück; was sind doppelt verkettete Listen? Führt das zu den besagten Binären Bäumen ? Fragen über Fragen..
Please help me a bit...



Also, zuerst mal musst du klarmachen, was es werden soll, FIFO oder LIFO (hast du ganz oben genannt).

Doppelt verkettete Listen (DVL): Das Beispiel oben ist eine einfach verkettete Liste, d.h. jedes Listenelement besitzt einen Zeiger auf das nächste Element in der Liste. Du kannst dich damit leicht vom Anfang der Liste zum Ende hangeln, aber nicht umgekehrt. Jedes Element kennt seinen Nachfolger, aber keins kennt seinen Vorgänger.

Bei der doppelten Verkettung kommt der Verweis auf den Vorgänger dazu:

C++:
struct Satz  {
    char Name[16];
    char Symbol [3];
    float Dichte;
    float Cellsius;
    int Xkor;
    int Ykor;

    struct Satz *next;
    struct Satz *prev; /* "previous" = vorheriger */
};


D.h. wenn die Zeiger alle richtig zurechtgebogen sind, kann man sich in beiden Richtungen gleich gut bewegen, und zwar über next zum jeweiligen Nachfolger und über prev zum Vorgänger.

Beim Implementieren der Einfüge- und Löschaktionen nimmt man gerne diese Bildchen zur Hilfe, um zu veranschaulichen, welche Schritte man in welcher Reihenfolge machen muss.

Code:
o------------o
|            |
o------------o
+ prev | next +
o------------o

o------------o           o------------o
|            |           |            |
o------------o           o------------o
+ prev | next +  ----->  + prev | next +
o------------o           o------------o



Eine DVL ist kein binärer Baum, sondern immer noch eine unverzweigte Struktur. Bäume sind noch was anderes.

ao

Dieser Post wurde am 24.11.2003 um 09:30 Uhr von ao editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
24.11.2003, 12:46 Uhr
0xdeadbeef
Gott
(Operator)


Ich würde dann auch gleich ne doppelt verkettete Dummy-Liste nehmen, das macht die Operationen einfacher. Die Idee dahinter ist, dass du am Anfang und am Ende der Liste ein sog. Dummy-Element hast. Das ist eine ganz normale Node, die keinen sinnvollen Wert enthält. Der prev-Zeiger der Head-Node zeigt auf sich selbst, entsprechend der next-Zeiger der Tail-Node. Der Head- und Tail-Pointer sind dadurch konstant, deswegen brauchen Einfüge- und Löschoperationen am Anfang und Ende der Liste keine Sonderbehandlung mehr. Mit diesen lustigen Bildchen sieht die Anfangskonfiguration dann so aus:

Code:
     +------+    +------+
   ->| next |--->| next |--
  (  +------+    +------+  )
   --| prev |<---| prev |<-
     +------+    +------+
        ^           ^
        |head       |tail
     +------------------+
     |    Listenkopf    |
     +------------------+


und die restlichen Elemente werden dann ganz normal zwischen den Dummies eingefügt.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 24.11.2003 um 12:48 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
24.11.2003, 12:53 Uhr
~Spacelord
Gast


Hi,
schau mal hier nach:
www.netzmafia.de/skripten/ad/ad10.html#7.3
Da findest du eine recht ausführliche Erklärung zu dynamyschen Datenstrukturen.

MfG Spacelord
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
24.11.2003, 19:48 Uhr
audaxx



Ersteinmal danke für die tips und die schnelle Hilfe.

Werde mir die Informationen mal zu Gemüte führen...

Also wir sollten jetzt diese Liste nocheinmal nach dem FIFO Prinzip schreiben und dann kommt bestimmt die Weiterführung mit einer doppelt verketteten Liste, da wir sonst nicht in unserem Menü vor und zurück könnten, welches wir ersteinmal beiseite gelegt haben.

Bin erst vor weniger Zeit auf dieses Forum gestoßen, während ich etwas über die Scard32.dll gesucht habe, die wir in einem VB Projekt verwenden..
Lob an alle ;-)

Wir haben morgen wieder C, werde die doppelte Verkettung und das Löschen mal versuchen..

Fun4U @ll
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
24.11.2003, 19:54 Uhr
Pablo
Supertux
(Operator)


Benutze 2 Zeiger (deshlab doppeltverkettete Liste) und hab immer im Head einen Zeiger auf das Head Element und einen anderen auf das tail Element. FIFO ist wie eine Schlange. Daten kommen und sammeln sich am Schluss und nur der Kopf wird verarbeitet, d.h. beim Entfernen eines Knotens bzw. bei Verdängen der Daten muss man das Head Element löschen.
--
A! Elbereth Gilthoniel!
silivren penna míriel
o menel aglar elenath,
Gilthoniel, A! Elbereth!
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
24.11.2003, 20:05 Uhr
audaxx



o.k., hat einer der Pointer standartmäßig den Wert NULL? Damit ich das Ende der Liste begrenzen/definieren kann?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
24.11.2003, 20:19 Uhr
Pablo
Supertux
(Operator)


nein. Beim Einfügen musst du "künstlich" NULL setzen.


C++:
// hier wurde schon am Schluss gesetzt, nun NULL setzen
tail->next=NULL;
// tail ist die Referenz auf da letzte Element der Liste.


--
A! Elbereth Gilthoniel!
silivren penna míriel
o menel aglar elenath,
Gilthoniel, A! Elbereth!
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: