[c] Algorytm LIFO/FIFO

chyl-o - 04-12-2006 18:59
Kurcze mam sobie taki algorytm w C i coś nie bardzo chce mi zadziałać tak jak chcę:

// LIFO

#include <stdio.h>
#include <stdlib.h>

struct Wezel {
int value;
struct Wezel *next, *prev;
};

struct Stos {
struct Wezel *top, *low;
};

void stos_new( struct Stos *s );
int push( struct Stos *s );
void pop( struct Stos *s, int val );
void stos_del( struct Stos *s );
//-------------------------------------------------
void main()
{
struct Stos *stos = malloc( sizeof( struct Stos ));
stos_new( stos );
pop( stos, 1 );
pop( stos, 12 );
pop( stos, 13 );
pop( stos, 14 );
pop( stos, 15 );
pop( stos, 16 );
printf("\n");
while( stos->top != 0 );
{
printf("%d ", push( stos ) );
}
printf("\n");
stos_del( stos );
}
//-------------------------------------------------
void stos_new( struct Stos *s ) {
s->low = 0;
s->top = 0;
}
//-------------------------------------------------
int push( struct Stos *s )
{
int val = s->top->value;
struct Wezel *stary = s->top;
s->top = s->top->prev;
free( stary );

return val;
}
//-------------------------------------------------
void pop( struct Stos *s, int val )
{
struct Wezel *nowy = malloc( sizeof( struct Wezel ) );
nowy->value = val;
if( s->top != 0 )
{
s->top->next = nowy;
nowy->prev = s->top;

}
else
{
s->low = nowy;
nowy->prev = 0;
}
s->top = nowy;
}
void stos_del( struct Stos *s )
{
struct Wezel *temp;
struct Wezel *check = s->top;
while( check != 0 )
{
temp = check;
check = s->top->prev;
free( temp );
}
free( s );
} nie bardzo wiem gdzie mam błąd, może ktoś wypatrzy go bo ja go nie widzę...

Lorenzo - 04-12-2006 22:48
Wiem, że to co zrobie nie jest zbyt pedagogiczne ;-)
Tutaj jest chyba lista jednokierunkowa (nie wiem czy lifo czy fifo).
Lista dwukierunkowa.

Mam nadzieje, że może coś oświeci. Możesz jeszcze spróbować dorwać jakąkolwiek ksiązke do C - te listy są wałkowane wszędzie ;-)

chyl-o - 02-01-2007 17:54
Dzisiaj przerobiłem cały algorytm i działa.

// LIFO

#include <stdio.h>
#include <stdlib.h>

struct Wezel {
int wartosc;
struct Wezel *pod, *nad;
};

struct Stos {
struct Wezel *top, *low;
};

void NowyStos( struct Stos *PStos );
void Push( struct Stos *PStos, int val );
int Pop( struct Stos *PStos );
void Usun( struct Stos *PStos );

int main()
{
struct Stos *lifo = malloc( sizeof( struct Stos ) );
NowyStos( lifo );
Push( lifo, 19 );
Push( lifo, 20 );
Push( lifo, 12 );
Push( lifo, 90 );
Push( lifo, 34 );
Push( lifo, 0 );
putchar('\n');
while( lifo->top != 0 )
{
printf("%d ", Pop( lifo ) );
}
Usun( lifo );
putchar('\n');

return 0;
}

void NowyStos( struct Stos *PStos )
{
PStos->top = 0;
PStos->low = 0;
}

void Push( struct Stos *PStos, int val )
{
struct Wezel *nowy = malloc( sizeof( struct Wezel ) );
nowy->wartosc = val;
if( PStos->top != 0 )
{
PStos->top->nad = nowy;
nowy->pod = PStos->top;
}
else
{
PStos->low = nowy;
}
PStos->top = nowy;
}

int Pop( struct Stos *PStos )
{
struct Wezel *temp = PStos->top;
int val = temp->wartosc;
PStos->top = temp->pod;
free( temp );

return val;
}

void Usun( struct Stos *PStos )
{
struct Wezel *temp;
while( PStos->top != 0 )
{
temp = PStos->top;
PStos->top = temp->pod;
free( temp );
}
free( PStos );
}

chyl-o - 02-01-2007 23:22
A przy okazji naskrobalem algorytm FIFO, może się komuś przyda.

// FIFO

#include <stdio.h>
#include <stdlib.h>

struct Wezel {
int wartosc;
struct Wezel *pod, *nad;
};

struct Stos {
struct Wezel *top, *low;
};

void NowyStos( struct Stos *PStos );
void Push( struct Stos *PStos, int val );
int Pop( struct Stos *PStos );
void Usun( struct Stos *PStos );

int main()
{
struct Stos *fifo = malloc( sizeof( struct Stos ) );
NowyStos( fifo );
Push( fifo, 19 );
Push( fifo, 76 );
Push( fifo, 28 );
Push( fifo, 101 );
Push( fifo, 88 );
Push( fifo, 3 );
putchar('\n');
while( fifo->low != 0 )
{
printf("%d ", Pop( fifo ) );
}
Usun( fifo );
putchar('\n');

return 0;
}

void NowyStos( struct Stos *PStos )
{
PStos->top = 0;
PStos->low = 0;
}

void Push( struct Stos *PStos, int val )
{
struct Wezel *nowy = malloc( sizeof( struct Wezel ) );
nowy->wartosc = val;
if( PStos->top != 0 )
{
PStos->top->nad = nowy;
nowy->pod = PStos->top;
}
else
{
PStos->low = nowy;
}
PStos->top = nowy;
}

int Pop( struct Stos *PStos )
{
struct Wezel *temp = PStos->low;
int val = temp->wartosc;
PStos->low = temp->nad;
free( temp );

return val;
}

void Usun( struct Stos *PStos )
{
struct Wezel *temp;
while( PStos->low != 0 )
{
temp = PStos->low;
PStos->low = temp->nad;
free( temp );
}
free( PStos );
}

DaViDeX - 12-01-2007 18:47
A nie lepiej skorzystać ze stack i queue z STL'a?

chyl-o - 15-01-2007 08:15

A nie lepiej skorzystać ze stack i queue z STL'a? Takie rozwiązanie nie wchodziło w grę niestety.

siwki - 06-01-2008 14:44
macie moze gdzies kod programu w C na czterodziałaniowy kalkulator RPN wykorzystujący dynamiczną listę jednokierunkową ?? byłabym bardzo wdzięczny za udostępnienie

ponton - 07-01-2008 00:36
Chętnie taki napiszę za drobną opłatą. ;)

adam majewski - 30-01-2008 19:18
u mnie programy nie kończą się ( nieskończona pętla ) ,