[c] Algorytm LIFO/FIFO

[chyl-o]

Kurcze mam sobie taki algorytm w C i coś nie bardzo chce mi zadziałać tak jak chcę:

Kod: Zaznacz cały

// 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]

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]

Dzisiaj przerobiłem cały algorytm i działa.

Kod: Zaznacz cały

// 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]

A przy okazji naskrobalem algorytm FIFO, może się komuś przyda.

Kod: Zaznacz cały

// 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]

A nie lepiej skorzystać ze stack i queue z STL'a?

[chyl-o]

A nie lepiej skorzystać ze stack i queue z STL'a?

Takie rozwiązanie nie wchodziło w grę niestety.

[siwki]

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]

Chętnie taki napiszę za drobną opłatą.

[adam majewski]

u mnie programy nie kończą się ( nieskończona pętla ) ,