Kolejka FiFo w C

[rubo]

Witam!
Pilnie potrzebuję napisanej kolejki fifo w języku c. Tzn program ma dodawać element do kolejki, usuwać element, sprawdzać czy kolejka jest pusta i zliczać elementy w kolejce.
Przykładowo to powinno wyglądać tak:
po uruchomieniu programu wyskakuje napis:

0- sprawdz czy kolejka jest pusta
1 - sprawdz ile elementow jest w kolejce
2 - dodaj element
3 - usun element

uzytkownik wybiera opcje i dopisuje badz usuwa element, czy ktos ma taki program napisany w c? Proszę o pomoc!! Dzięki!

[droopy]

implementracja stosu (który jest taką właśnie kolejką) na liście wiązanej
w tym przykładzie został on użyty do obliczania wyrażenia postfixowego, więc musisz sobie przerobić...

Kod: Zaznacz cały

 typedef int dane; 													// dane umieszczone stosie
 typedef struct ELEMENT* stos;   					//nazwa wskaźnika na element stosu
 struct ELEMENT
  {
   dane Dane;
   stos Nastepny;
  };
 							//funkcje ADT stosu
 void Inicjalizacja(stos& Stos);
 inline int Pusty(stos Stos);
 int Wstaw(stos& Stos, dane Dana);
 dane Usun(stos& Stos);

 //2. funkcje we/wy dla danych umieszczonych na stosie
 void Pokaz_dane (dane Dana);   			//funkcja do wyświetlania danej
 dane Dane();												// funkcja do wprowadzania danej

 //3. funkcje ogolnego przeznaczenia
  void Komunikat(char*);											//funkcja do wyświetlania komunikatów
  char Menu(const int ile, char *Polecenia[]);		//funkcja do wyświetlania tablicy //łańcuchów zawierających menu programu i zwracająca naciśniety klawisz

//4. elementy programu
const int Esc=27;
const int POZ=5;
char * Tab_menu[POZ] = {	"1 : Wstawianie do stosu- na poczatek",
			 										"2 : Usuwanie ze stosu-na poczatku",
													"3 : Wydruk stosu wraz z jego usuwaniem",
													"4 : Obliczanie wyrazenia postfiksowego", 
                        					 	" >Esc Koniec programu"};

//funkcja klienta korzystające ze stosu
void Wyswietl_usun_ze_stosu(stos& Stos); //wyświetlanie stosu
dane Oblicz(char* w, stos& Stos); //zastosowanie stosu do obliczenia wyrażenia //postfiksowego
void main(void)
 { stos Stos;
   char Wybor;
   char w[19]= {'5',' ','9','1',' ','8','2',' ','+','4',' ','6',' ','*','*','7',' ','+','*'};
   
   clrscr();
   Inicjalizacja(Stos);
   do
   		{ Wybor= Menu(POZ, Tab_menu);
   		  switch (Wybor)
    		{ 
case '1' : 	dane Dana=Dane();
                if (Wstaw(Stos, Dana)==0)
                                 Komunikat("Brak pamieci\n");
               	break;
     			case '2' : 	if (Pusty(Stos))
                   					 Komunikat("\nStos pusty\n");
                					else (Usun(Stos));
									break;
     			case '3' : 	if (Pusty(Stos))
		 								Komunikat("\nStos pusty\n") ;
               					else Wyswietl_usun_ze_stosu(Stos);
                 				break;
             case '4' :  printf("\n%d\n", Oblicz(w, Stos)); 
                             getch();
    }
   } while (Wybor !=Esc );
  }

//**************funkcje klienta korzystające ze stosu***********

void Wyswietl_usun_ze_stosu(stos& Stos)
    {dane d;
     while (!Pusty(Stos))
      {
	    d=Usun(Stos);
        Pokaz_dane(d);
      }
    }


 
dane Oblicz(char* w, stos& Stos) //wg Robert Sedgewick „Algorytmy w C++”
  {
    for ( int i=0;i<19; i++)
      {  if (w[i]=='+')
             Wstaw(Stos,Usun(Stos)+Usun(Stos));
         if (w[i]=='*')
             Wstaw(Stos,Usun(Stos)*Usun(Stos));
         if (w[i]>='0' && w[i]<='9')
            Wstaw(Stos,0);
         while(w[i]>='0' && w[i]<='9')
             Wstaw(Stos,10*Usun(Stos)+(w[i++]-'0'));
       }
      return Usun(Stos);
  }

//*********funkcje interfejsu ADT stosu************
 
 void Inicjalizacja(stos& Stos)
   {  Stos = NULL; }

 inline int Pusty(stos Stos)
   { return Stos==NULL;	}

 int Wstaw(stos& Stos, dane Dana)
  { stos Nowy;
    Nowy = new ELEMENT;  
    if (!Pusty(Nowy))   Nowy->Dane=Dana;
    else return 0;
    
    Nowy->Nastepny= Stos;
    Stos= Nowy;
    return 1;
   }

 dane Usun(stos& Stos)
   {stos Pom;
    dane d;
    Pom = Stos;
    Stos = Stos->Nastepny;
    d= Pom->Dane;    											//((*Pom).Dane)
    delete Pom;
    return d; }
 
//*********funkcje ogólnego przeznaczenia************

char Menu(const int ile, char *Polecenia[])
  {
   clrscr();
   for (int i=0; i<ile;i++)
        printf("\n%s",Polecenia[i]);
   return getch();
  }

 void Komunikat(char* s)
  {
   printf(s); 
   getch();
  }

//*******funkcje we/wy dla danych umieszczonych na stosie*********
 
dane Dane()
   { int a;
    do
     { fflush(stdin);
       printf("\n\nPodaj dane typu int: ");
     } while (scanf("%d",&a)!=1);
    return a;
   }

  void Pokaz_dane(dane Dana)
   {
    printf("\nNumer: %d\n", Dana);
    printf("Nacisnij dowolny klawisz...\n"); 
    getch();
   }

[Fibik]

Stos = LIFO, kolejka = FIFO.
Czyli stos nie jest kolejką.

Kod: Zaznacz cały

int isEmpty() { return !head; }

[rubo]

No właśnie stos - to jest lifo, a mi chodzilo a podobny program jaki napisał kolega tyle, że dotyczący fifo (dodawanie na koniec kolejki, usuwanie z poczatku), wiec jak powinien wygladac ten kod w c? Prosze niech mi ktos pomoze... To bardzo wazna sprawa...

[Fibik]

Kod: Zaznacz cały

#include <stdio.h>

struct TElem
{
  TElem *next;
  char label[4]; 
};

TElem *head = 0;  // początek kolejki

int Pusta() { return head == 0; }

TElem *last()  // ostatni z kolejki
{
 TElem *e = head;

 if( e )
  for( ; e->next; e = e->next)
     ;

 return e;
}

TElem *find(char *s)  // szuka w kolejce
{
 TElem *e = head;

 for( ; e && stricmp(e->label, s) != 0; e = e->next)
     ;

 return e;
}

int getCount() // długość kolejki
{
 int n;
 TElem *e = head;
 for(n = 0; e; e = e->next) n++;
 return n;
}

void list()  // wszystko na ekran
{
 TElem *e = head;
 for(int n = 0 ; e; e = e->next)
  printf("%3d %s\n", ++n, e->label);
}

int add()  // wstawiamy do kolejki
{
  char s[256];
  puts("Wpisz identyfikator: ");
  gets(s);

  if( !s[0] ) return 0; // bez etykiety nie wstawiamy

  if( find(s) )  // może już jest...
   {
     printf("ten już stoi w kolejce...\n");
     return 0;
   }

  TElem *e = (TElem*)malloc(sizeof(*e) - sizeof(e->label) + strlen(s)+1);
  if( !e ) { puts("Brak pamięci!\n"); return -1; }

  e->next = 0;
  strcpy(e->label, s);

  TElem *lst = last();
  if( lst ) lst->next = e; // zaczepiamy do na końcu
  if( !head ) head = e;  // kolejka była pusta

  return 1;
}

int del()
{
  if( !head ) return 0;

  TElem *e = head;
  head = e->next;      // odchodzi pierwszy

  printf("%s - wychodzi\n", e->label);
  free(e);  // zwalniamy pamięć
  return 1;
}

//------- pętla główna --------
void manipuluj()
{
 char s[80]; s[0] = '1';
 while( s[0] )
 {
  if( s[0] >= '1' && s[0] <= '3' )
   printf("1: dodaj  2: usun  3: listuj    ESC: end\n>");

  gets(s); // można użyć getch() z 'conio.h'
  switch( *s )
  {
  case '1' : add(); break;
  case '2' : del(); break;
  case '3' : list(); break;
  case 27  : s[0] = 0; break;
  }
 }

/* zniszczymy kolejkę... albo nie - i tak koniec */
}

int main() { manipuluj(); return 0; }

Jakoś tak, ale nie uruchamiałem tego.
Komentarze:
// xxxxxxxx
trzeba zamienić na:
/* xxxxxxx */