terça-feira, 9 de outubro de 2007

Estrutura de Dados
Fila (FIFO)

Teoria:

Sequência ordenada de elementos, podendo ser adicionados novos elementos numa das extremidades (parte de trás ou cauda) e retirados na outra extremidade (parte da frente ou cabeça).
Só os elementos que estão à frente é que podem ser retirados;
Só se pode adicionar novos elementos na parte de trás;
A fila de espera comporta- se como um FIFO (“First- IN, First- Out”).

Depois de muito queimar a mufa, descobri que a melhor resposta era CTRL + C, CTRL + V...
Com um código-fonte gentilmente cedido por uma pessoa que conheci hoje na faculdade, fiz umas adaptações no código anterior:


#include <stdio.h>
#include <malloc.h>

typedef struct temp
{
int dado;
struct temp *prox;
}pilha;

pilha *chao,*topo, *novo;

// colocar aqui funções de manipulação

void inserir()
{
novo=(pilha*) malloc (sizeof(pilha));
printf("\n\tDigite o dado p/ armazenar=
"
);
scanf("%d", &novo->dado); //armazenar 1 valor em um dado
novo -> prox = NULL;
if (chao==NULL) //fila vazia
chao=novo;
else
topo->prox = novo;
topo = novo;
}


void retirar()
{
if(topo==NULL)
{
printf("\n\tPilha vazia!");
return;
}
novo = chao;

chao = chao->prox;

free(novo); //"desalocar", liberar memória
}

void mostrar()
{
if(chao==NULL)
{
printf("\n\tPilha vazia!");
return;
}
novo = chao; //começa do chao
while (novo != NULL)
{
printf("\t%d", novo->dado);
novo = novo->prox; //vá p/ o próximo!
}
}

main()
{
chao = topo = novo = NULL; //pilha vazia!
int op;
do
{
printf("\n\nDigite uma opcao: ");
printf("\n\t1-Inserir\n\t2-Retirar");
printf("\n\t3-Mostrar\n\t4-Fim\n\n->");
scanf("%d", &op);
switch(op)
{
case 1: inserir(); break;
case 2: retirar(); break;
case 3: mostrar(); break;
case 4: break;
default: printf("\n\t***Erro!");
}
}while (op != 4);
}

* Os Sñrs devem ter ouvido o professor falar
que poderia ser feito sem o uso de outra referência (ponteiro), não? Pois o desafio agora é esse. Buenas suertes...

Um comentário:

Illuminat disse...

/* Organização de fila: FIFO (first in, first out)
* Os elementos vão sendo executados do ponteiro do início da fila até o
* ponteiro do final da fila (o ponteiro nulo, null)
*/


#include<stdio.h>
#include<malloc.h>

typedef struct temp
{
int dado;
struct temp *prox;
}fila;

fila *inicio, *fim, *novo;

void inserir()
{
novo = (fila*) malloc (sizeof(fila));
printf("\n\tDado a inserir: ");
scanf("%d", &novo -> dado);
novo -> prox = NULL;
if (inicio == NULL) //fila vazia
inicio = novo;
else
fim -> prox = novo;
fim = novo;
}

void retirar ()
{
if (inicio == NULL)
{
printf("\n\tFila vazia!");
return;
}
novo = inicio;
inicio = inicio -> prox;
free(novo);
}

void mostrar()
{
if (inicio == NULL)
{
printf("\n\tFila vazia!");
return;
}
novo = inicio;
printf("\n\n");

while (novo != NULL)
{
printf("%d ", novo -> dado);
novo = novo -> prox;
}
}

main()
{
int op;
inicio = fim = novo = NULL;
do
{
printf("\n\nDigitie a opcao:");
printf("\n1 - Inserir");
printf("\n2 - Retirar");
printf("\n3 - Mostrar");
printf("\n4 - Fim");
printf("\n\n");
scanf("%d", &op);

switch(op)
{
case 1: inserir(); break;
case 2: retirar(); break;
case 3: mostrar(); break;
case 4: break;
default: printf("\nErro!");
}
}while(op != 4);
}