Filas em C - Como Programar a

Estrutura de Dados
Funo main(), opcao() e menu()
Ok, agora que j sabemos o que uma fila e como funciona, vamos comear a implementar
essa estrutura de dados em C, partindo do zero, apenas baseado no que sabemos da definio
de FIFO.
Inicialmente criamos uma struct chamada Node, que vai criar os ns de nossa estrutura de
dados.
Vamos colocar nela um inteiro, o "num" para armazenar um valor qualquer inserido pelo
usurio.
Obrigatoriamente, temos que inserir nessa struct um ponteiro de seu prprio tipo.
Vamos chamar esse ponteiro de "prox" pois ele vai servir para apontar para o prximo n da
estrutura.
Caso esse ponteiro aponte para NULL, porque seu n o ltimo da fila ou a fila est vazia.
De resto, a funo principal main() simplesmente fica chamando (em um looping do while) a
funo menu(), que simplesmente exibe as opes possveis para se trabalhar com a fila em C.
Depois que o usurio escolhe o que fazer, sua escolha enviada para a funo opcao(), que
usa um teste condicional do tipo switch para invocar a funo correta.

Funo aloca() e inicia()

Inicialmente, criamos um ponteiro para a struct Node, o "FILA", e ele a representao de
nossa estrutura de dados do tipo fila.
Seu inteiro no importa, a funo deste ponteiro definida pelo seu ponteiro "prox".
O vetor "prox" aponta pro primeiro elemento da fila, e caso ele no exista, a fila est vazia e
"prox" aponta para NULL.
Fazemos isso na funo inicia(), que inicializa a fila fazendo: FILA->prox = NULL
Devemos sempre lembrar de alocar memria para cada n de nossa fila, o que feito pela
funoaloca().

Funo vazia()
No decorrer de nosso programa sobre estrutura de dados do tipo fila, muitas vezes ser
necessrio checar se a fila est vazia ou no.
Isso feito de uma maneira bem simples: checando o ponteiro "prox" da struct "FILA".
Se apontar pra NULL, a fila est vazia. Do contrrio, tem pelo menos um elemento na fila.

Funo insere()
Antes de mais nada, vamos usar a funo aloca() para reservar um espao em memria para o
novo n, o "novo". Como este novo n ser o ltimo da fila, seu ponteiro "prox" deve apontar

para NULL.
Esta foi a primeira parte do processo de se adicionar um elemento em uma fila.
A segunda parte adicionar este novo n ao final da fila, e para tal, devemos achar o ltimo n
da fila.
Primeiro checamos se a fila est vazia, pois se tiver, basta colocar no novo n em FILA->prox
Caso no esteja, criamos um ponteiro "tmp" que vai apontar para todos os elementos da fila em
busca do ltimo. Ele comea no primeiro elemento, que est em "FILA->prox".
Se "tmp->prox" apontar para NULL, o ponteiro aponta para o ltimo da fila.
Seno, devemos seguir adiante com o ponteiro (tmp = tmp->prox) at acharmos o ltimo
elemento.
Achando, colocamos l o novo n, o "novo".
A varivel inteira "tam" para definir o tamanho da fila (nmero de ns). Usaremos este inteiro
na funo "exibe()", que vai exibir os elementos da fila.

Funo retira()
Vamos agora retirar um elemento da fila.
E segunda a lgica deste tipo de estrutura de dados, vamos retirar o primeiro n.
Antes de tudo, checamos se a fila no est vazia.
Se estiver, trabalho feito, pois no precisaremos retirar n algum da estrutura de dados.
Caso a fila no esteja vazia, precisamos identificar o primeiro elemento e o segundo (na
verdade, no obrigado que exista um segundo elemento). O que precisamos fazer que
"FILA->prox" no aponte mais para o primeiro elemento, e sim para o segundo.
Vamos usar um ponteiro "tmp" para apontar para o primeiro elemento da fila: tmp = FILA->prox
Se "tmp" aponta para o primeiro elemento, ento "tmp->prox" aponta para o segundo elemento
ou NULL, caso a fila s tenha um n.
Agora vamos fazer a ligao entre o ponteiro base (FILA) e o segundo elemento (ou NULL) da
fila:
FILA->prox = tmp->prox
Pronto. Tiramos o primeiro elemento da jogada, pois se ningum aponta para ele, ele no faz
mais parte da estrutura de dados.
Interessante, no?
Note que declaramos a funo "retira()" como sendo do tipo struct Node, pois uma boa
prtica retornar o n que retiramos, pois geralmente retiramos ele da estrutura para fazer algo,
trabalhar em cima dele. Depois que retornamos ele pra funo "opcao()" liberamos o espao
que havia sido alocado para ele.

Funo exibe()
Esta funo serve somente para mostrar os nmeros ("num") existentes em cada n, para voc
poder adicionar, retirar e ver o que vai acontecendo com a fila.
Ou seja, esta funo tem mais propsitos didticos, pra voc ver as coisas realmente
funcionamento na sua frente, como devem funcionar.
Basicamente pegamos um ponteiro "tmp" e fazemos ele apontar para cada um dos ns,
exibindo o nmero. Para saber o tanto de ns existentes e a ordem, usamos a varivel "tam"
que incrementada quando adicionamos n na fila (funo insere) e decrementada quando
tiramos elementos da estrutura de dados (funo retira).

Funo liberta()
Esta funo simplesmente tem por objetivo ir em cada n e liberar a memria alocada.
Para tal, usamos dois ponteiros.
Um ponteiro aponta para um n ("atual"), e o outro ponteiro aponta para o n seguinte
("proxNode").
Liberamos o primeiro ponteiro, ou seja, aquele n deixa de existir.
Se tivssemos s este ponteiro, nos perderamos na fila.
Porm, o ponteiro que aponta para o n seguinte da fila serve pra isso, pois agora temos o
ponteiro para o prximo elemento da fila "proxNode").
Agora damos um passo pra frente, fazendo um ponteiro apontar para este prximo elemento
("atual = proxNode"), e o ponteiro prximo, para uma posio a frente ("proxNode = proxNode>prox").
E repetimos o processo at que o n atual seja NULL (fim da fila).