Algoritmos e Estruturas de Dados

Mdulo 7
Estruturas de Dados

Prof. Alexandre Siqueira Dias
alexandresd@prof.una.br
Tipos de Dados
Conjunto de valores possveis que cada
varivel pode possuir
NUMRICO
INTEIRO
Ex.: -23, 98, 0, 560
REAL
Ex.: 23,45; -364,89; 0,0
LGICO (BOOLEANO)
VERDADEIRO/FALSO
Tipos de Dados
LITERAL OU CARACTERE
Letras (maisculas e minsculas)
Nmeros
Caracteres especiais (&, #, @, ?, + etc.)
Ex.: 'aluno', '1234', '@ internet'
Novos Tipos de Dados
Nem sempre os tipos bsicos (inteiro,
real, caractere e lgico) so suficientes
para exprimir estruturas de dados em
algoritmos.
Necessidade de novos tipos de dados
serem criados
Homogneos
Vetores
Matrizes
Heterogneos
Registros
Registro
O registro um conjunto de dados
logicamente relacionados
Utiliza vrios dados de tipos diferentes
em uma mesma estrutura
Por isso considerado heterogneo.
Cada elemento (campo) pode ser
referenciado de forma nica pelo seu
nome
Registro em C/C++
struct
{
tipo_dados campo1,
tipo_dados campo2

} variavel_struct;

ou

struct nome_struct
{
tipo_dados campo1,
tipo_dados campo2

};




Registro em C/C++
Ex.:
struct {
int dia;
int mes;
int ano;
} d;
Declara um registro d que possui os campos dia, mes e ano.

struct data {
int dia;
int mes;
int ano;
};
Declara um tipo de registro chamado data que possui os campos dia, mes e ano.

Sintaxe C
struct data x; /* declara um registro x do tipo data */
struct data y; /* declara um registro y do tipo data */

ou
Sintax C++
data x; /* declara um registro x do tipo data */
data y; /* declara um registro y do tipo data */
Tipo Abstrato de Dados - TAD
Especifica um conjunto de dados e as operaes que
podem ser executadas sobre esses dados
Exemplo:
estrutura Estudante{
Nome
Idade
Matricula
}
funcao Estudante_MaiorDeIdade(Estudante estudante) retorna booleano;
funcao Estudante_ValidaMatricula(Estudante estudante) retorna booleano;

Estruturas de Dados
A qualidade da soluo de um problema
depende, dentre outros fatores, da
forma como os dados relevantes esto
organizados
Encontrar o nmero do telefone de um
certo cliente no conjunto de todos os
clientes.
Representao interna de uma string
Estruturas de Dados
Estruturas de dados so formas genricas de se
estruturar informao de modo a serem registradas e
processadas pelo computador
Ex.:
lista ordenada;
vetores;
rvores;
grafos etc.
Estas s adquirem significado quando associadas a
um conjunto de operaes, que visam, de um modo
geral, manipul-las (algoritmos)
Tipos de Dados, Tipos Abstratos de
Dados e Estruturas de Dados
Tipo de dados
usado no contexto de uma linguagem de
programao (tipos primitivos) e est associado a
um mtodo de interpretar um padro de bits
Tipo abstrato de dado (TAD)
modelo junto com um conjunto de operaes
definidas sobre o modelo (tipo + operaes
validas)
Estrutura de dados
forma concreta de se implementar um TAD, ou
seja, uma representao computacional do
modelo matemtico em questo
Estrutura de dados Lista linear
Agrupa informaes referentes a um
conjunto de elementos que, de alguma
forma, se relacionam entre si.
Exemplos:
gerncia de memria
informaes sobre os funcionrios de uma
empresa
notas de alunos etc.
Cada item chamado de n
Estrutura de dados Lista linear
Exemplos de operaes possveis:
Criar uma lista vazia
Inserir um item em uma determinada
posio
Remover o i-simo item
Retornar o i-simo item
Ordenar os itens
Pesquisar se um determinado item
pertence ou no lista
Estrutura de dados Lista linear
Tipos de implementao
Alocao sequencial
Realizada com reserva de memria
Alocao esttica
Os itens so armazenados em um vetor
suficiente para armazenar a lista
O i-simo item est armazenado na i-
sima posio do vetor
Maior esforo computacional para
insero e remoo




Estrutura de dados Lista linear
Implementao alocao sequencial lista.hpp



#define MAX_TAM 1000
#define TipoItem int

struct tipoLista
{
TipoItem Item[MAX_TAM];
int Primeiro, Ultimo;
};

void inicializarLista(tipoLista &lista);
int listaVazia(tipoLista &lista);
void inserir(tipoLista &lista, TipoItem x);
void imprimir(tipoLista &lista);

Estrutura de dados Lista linear
Implementao alocao sequencial lista.cpp



void inicializarLista(tipoLista &lista)
{
lista.Primeiro = 0;
lista.Ultimo = lista.Primeiro;
}

int listaVazia(tipoLista &lista)
{
return (lista.Primeiro == lista.Ultimo);
}
Estrutura de dados Lista linear
Implementao alocao sequencial lista.cpp




void inserir(tipoLista &lista, TipoItem x)
{
if (lista.Ultimo >= MAX_TAM)
cout << "Lista cheia\n";
else
{
lista.Item[lista.Ultimo] = x;
lista.Ultimo++;
}
}

void imprimir(tipoLista &lista)
{
int Aux;
cout << "\nImprimindo Lista Estatica: \n";
for (Aux = lista.Primeiro; Aux < lista.Ultimo; Aux++)
cout << \n<< lista.Item[Aux];
}

Estrutura de dados Lista linear
Implementao alocao sequencial main.cpp




int main(int argc, char *argv[])
{
tipoLista lista;

inicializarLista(lista);
inserir(lista, 10);
inserir(lista, 20);
inserir(lista, 30);
inserir(lista, 40);

imprimir(lista);

system("PAUSE");
return 0;
}
Estrutura de dados Lista linear
Exerccio

Implementar as funes:
localizarItem(tipoLista &lista, TipoItem item)
Esta funo ir receber uma lista e um item como parmetros. Dever
retornar o ndice do vetor onde o item se localiza. Caso o mesmo no
esteja na lista, retornar o valor -1 (caso o item se encontre em mais de
uma posio na lista, retorne a posio da primeira ocorrncia deste
item).

excluirItem(tipoLista &lista, TipoItem item)
Esta funo ir receber uma lista e um item como parmetros. Dever
excluir o item da lista, caso o mesmo se encontre na lista. Caso
contrrio, emita uma mensagem informando que o item no se
encontra na lista. Utilize a funo localizarItem para localizar o item
antes de exclu-lo.
Adaptar a lista para passar a armazenar os dados de um aluno,
contendo matrcula e nome.

Estrutura de dados Lista linear
Tipos de implementao
Alocao encadeada
Permite o crescimento dinmico da lista
Cada item encadeado com o seguinte
atravs de uma varivel do tipo ponteiro
Permite inserir e remover itens sem
deslocar os itens seguintes da lista
Clula cabea para simplificar as
operaes sobre a lista



Estrutura de dados Lista linear
Implementao alocao encadeada lista.hpp



#define TipoItem int

struct tipoNodo
{
tipoNodo *Proximo;
TipoItem Item;
};

struct tipoLista
{
tipoNodo* Primeiro;
tipoNodo* Ultimo;
};
void FLVazia(tipoLista *Lista);
int listaVazia(tipoLista *Lista);
tipoLista* inicializarLista();
void inserirNoInicio(tipoLista *Lista, TipoItem item);
void inserirNoFim(tipoLista* Lista, TipoItem item);
void inserirOrdenado(tipoLista* Lista, TipoItem item);
void imprimir(tipoLista *Lista);
void liberar(tipoLista* Lista);

Estrutura de dados Lista linear
Implementao alocao encadeada lista.cpp



#include <iostream>
#include "lista.hpp"

using namespace std;

void FLVazia(tipoLista *Lista)
{
Lista->Primeiro = NULL;
Lista->Ultimo = NULL;
}

int listaVazia(tipoLista *Lista)
{
return (Lista->Primeiro == NULL);
}

tipoLista* inicializarLista()
{
tipoLista* lista = new tipoLista;
FLVazia(lista);
return lista;
}
Estrutura de dados Lista linear
Implementao alocao encadeada lista.cpp



tipoNodo* inicializarTipoNodo()
{
tipoNodo* x = new tipoNodo;
x->Proximo= NULL;
return x;
}

void inserirNoInicio(tipoLista *Lista, TipoItem item)
{
tipoNodo *Nodo;
Nodo = inicializarTipoNodo();

Nodo->Item = item;
Nodo->Proximo = Lista->Primeiro;

if(listaVazia(Lista))
Lista->Ultimo = Nodo;

Lista->Primeiro = Nodo;
}

Estrutura de dados Lista linear
Implementao alocao encadeada lista.cpp


void inserirNoFim(tipoLista* Lista, TipoItem item)
{
tipoNodo *Nodo;
Nodo = inicializarTipoNodo();

Nodo->Item = item;

if(listaVazia(Lista))
Lista->Primeiro = Nodo;
else
Lista->Ultimo->Proximo = Nodo;

Lista->Ultimo = Nodo;
}

Estrutura de dados Lista linear
Implementao alocao encadeada lista.cpp


void inserirOrdenado(tipoLista* Lista, TipoItem item)
{
tipoNodo *aux, *ant;

tipoNodo *Nodo = inicializarTipoNodo();

Nodo->Item = item;

aux = Lista->Primeiro, ant = NULL;

while ((aux != NULL) && (aux->Item < item))
{
ant = aux;
aux = aux->Proximo;
}

if (ant == NULL)
Lista->Primeiro = Nodo;
else
ant->Proximo = Nodo;

Nodo->Proximo = aux;

if (aux == NULL)
Lista->Ultimo = Nodo;
}
Estrutura de dados Lista linear
Implementao alocao encadeada lista.cpp


void imprimir(tipoLista* Lista)
{
tipoNodo* aux;
cout << "\nImprimindo Lista Dinamica: \n";
aux = Lista->Primeiro;
while (aux != NULL)
{
cout << "\n" << aux->Item;
aux = aux->Proximo;
}
}
Estrutura de dados Lista linear
Implementao alocao encadeada lista.cpp


void liberar(tipoLista* Lista)
{
tipoNodo* aux;

aux = Lista->Primeiro;

while(aux != NULL)
{
aux = aux->Proximo;
delete(Lista->Primeiro);
Lista->Primeiro = aux;
}
delete (Lista);
}
Estrutura de dados Lista linear
Implementao alocao encadeada main.cpp


#include <cstdlib>
#include <iostream>
#include "lista.hpp"

using namespace std;

int main(int argc, char *argv[])
{
tipoLista* lista = inicializarLista();

inserirNoInicio(lista, 10);
inserirNoInicio(lista, 20);
inserirNoFim(lista, 30);
inserirNoFim(lista, 40);

imprimir(lista);
liberar(lista);

system("PAUSE");
return EXIT_SUCCESS;
}
Estrutura de dados Lista linear
Problemas com a lista simplesmente
encadeada:
Localizar item
Inserir item de forma ordenada
Remover item
Percorrer a lista em ordem inversa
Soluo:
Lista duplamente encadeada

Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.hpp



#define TipoItem int
#define tipoNodo struct TipoNodo
#define tipoLista struct TipoLista

void FLVazia(tipoLista *Lista);
int listaVazia(tipoLista *Lista);
tipoLista* inicializarLista();
void inserirNoInicio(tipoLista *Lista, TipoItem item);
void inserirNoFim(tipoLista* Lista, TipoItem item);
void inserirOrdenado(tipoLista* Lista, TipoItem item);
void imprimir(tipoLista *Lista);
void imprimirInverso(tipoLista *Lista);
void liberar(tipoLista* Lista);
void excluirItem(tipoLista* Lista, TipoItem item);
Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp



#include <iostream>
#include "lista.hpp"

using namespace std;

struct TipoNodo
{
TipoNodo *Proximo, *Anterior;
TipoItem Item;
};

struct TipoLista
{
TipoNodo* Primeiro;
TipoNodo* Ultimo;
};
Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp



void FLVazia(tipoLista *Lista)
{
Lista->Primeiro = NULL;
Lista->Ultimo = NULL;
}

int listaVazia(tipoLista *Lista)
{
return (Lista->Primeiro == NULL);
}

tipoLista* inicializarLista()
{
tipoLista* lista = new tipoLista;
FLVazia(lista);
return lista;
}
Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp



tipoNodo* inicializarTipoNodo()
{
tipoNodo* x = new tipoNodo;
x->Proximo= x->Anterior= NULL;
return x;
}

void inserirNoInicio(tipoLista *Lista, TipoItem item)
{
tipoNodo *Nodo;
Nodo = inicializarTipoNodo();

Nodo->Item = item;
Nodo->Proximo = Lista->Primeiro;

if(listaVazia(Lista))
Lista->Ultimo = Nodo;
else
Lista->Primeiro->Anterior = Nodo;

Lista->Primeiro = Nodo;
}

Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp


void inserirNoFim(tipoLista* Lista, TipoItem item)
{
tipoNodo *Nodo;
Nodo = inicializarTipoNodo();

Nodo->Item = item;

if(listaVazia(Lista))
Lista->Primeiro = Nodo;
else {
Nodo->Anterior = Lista->Ultimo;
Lista->Ultimo->Proximo = Nodo;
}

Lista->Ultimo = Nodo;
}

Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp


void inserirOrdenado(tipoLista* Lista, TipoItem item)
{
tipoNodo *aux;
tipoNodo *Nodo = inicializarTipoNodo();
Nodo->Item = item;

if (listaVazia(Lista)){
Lista->Primeiro = Nodo;
Lista->Ultimo = Nodo;
}
else {
aux = Lista->Primeiro;
while ((aux != NULL) && (aux->Item < item))
aux = aux->Proximo;

if (aux == Lista->Primeiro){
Nodo->Proximo = Lista->Primeiro;
Lista->Primeiro->Anterior= Nodo;
Lista->Primeiro = Nodo;
}
else if (aux == NULL){
Lista->Ultimo->Proximo = Nodo;
Nodo->Anterior = Lista->Ultimo;
Lista->Ultimo = Nodo;
}
else {
Nodo->Proximo = aux;
aux->Anterior->Proximo = Nodo;
Nodo->Anterior = aux->Anterior;
aux->Anterior = Nodo;
}

}
}

Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp


void imprimir(tipoLista* Lista)
{
tipoNodo* aux;
cout << "\nImprimindo Lista Dinamica: \n";
aux = Lista->Primeiro;
while (aux != NULL)
{
cout << "\n" << aux->Item;
aux = aux->Proximo;
}
}
Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp


void imprimirInverso(tipoLista* Lista)
{
tipoNodo* aux;
cout << "\nImprimindo Lista Dinamica: \n";
aux = Lista->Ultimo;
while (aux != NULL)
{
cout << "\n" << aux->Item;
aux = aux->Anterior;
}
}
Estrutura de dados Lista linear
Implementao alocao duplamente encadeada lista.cpp


void liberar(tipoLista* Lista)
{
tipoNodo* aux;

aux = Lista->Primeiro;

while(aux != NULL)
{
aux = aux->Proximo;
delete(Lista->Primeiro);
Lista->Primeiro = aux;
}
}
Estrutura de dados Lista linear
Implementao alocao duplamente encadeada main.cpp


#include <cstdlib>
#include <iostream>
#include "lista.hpp"

using namespace std;

int main(int argc, char *argv[])
{
tipoLista* lista = inicializarLista();

inserirNoInicio(lista, 10);
inserirNoInicio(lista, 20);
inserirNoFim(lista, 30);
inserirNoFim(lista, 40);

imprimir(lista);
liberar(lista);

system("PAUSE");
return EXIT_SUCCESS;
}
Estrutura de dados Lista linear
Trabalho (entrega dia 18/04)
Alterar a implementao da lista duplamente encadeada, para
passar a utilizar os recursos da linguagem C++:
Alterar forma de passagem de parmetro por referncia (de * para &)
Alterar forma de alocao de memria (malloc e free por new e delete)
Implementar uma lista contendo um time, seu cdigo, e para
cada time, armazenar o cdigo, o nome e nmero da camisa
dos seus trs principais jogadores
Tanto os times quanto os jogadores devem ser armazenados
por ordem alfabtica de nome. Os cdigos devem ser gerados
automaticamente, medida que os itens forem inseridos na
lista
Implementar funes para:
Inserir um time na lista
Inserir os jogadores na lista
Remover um time da lista (atravs de seu cdigo)
Remover um jogador de um time (atravs de seu cdigo)
Imprimir todos os times em ordem crescente e decrescente de nome, com seus
jogadores, tambm em ordem crescente e decrescente de nome
Imprimir um time especfico, com seus jogadores


Pilha
Lista linear onde tanto a operao de insero quanto a
de retirada so realizadas no final (topo da pilha):
O primeiro elemento inserido ser o ltimo a ser retirado
O ltimo elemento inserido ser o primeiro a ser retirado
Chamada LIFO (Last In, First Out)
Aplicaes
Anlise de sintaxe de expresses
1 * ( 2 [ 5 + { 7 + 9 }] ) e 2 * { 3 ( 4 + [ 2 + 3 ] ) } vlidas
2 * ( 3 [ 4+5 ) ] invlida
Algoritmos recursivos

Pilha
Duas operaes bsicas
Empilhar (push)
Inserir um novo elemento no topo
Desempilhar (pop)
Retirar o elemento do topo
Pilha
Implementao alocao esttica pilha.hpp

#define tipoPilha struct TipoPilha
#define tipoItem int

tipoPilha* inicializaPilha();
int vazia(tipoPilha* Pilha);
void empilha(tipoItem item, tipoPilha* Pilha);
tipoItem desempilha(tipoPilha* Pilha);
void libera(tipoPilha* Pilha);
Pilha
Implementao alocao esttica
pilha.cpp

#include "pilha.hpp"
#include <iostream>
#define MaxTam 1000

using namespace std;

struct TipoPilha
{
tipoItem Item[MaxTam];
int Ultimo;
};


Pilha
Implementao alocao esttica pilha.cpp
TipoPilha* inicializaPilha()
{
TipoPilha* pilha = new TipoPilha;
pilha->Ultimo = 0;
return pilha;
}

int vazia(TipoPilha* Pilha)
{
return (Pilha->Ultimo == 0);
}

Pilha
Implementao alocao esttica pilha.cpp

void empilha(tipoItem item, tipoPilha* Pilha)
{
if (Pilha->Ultimo >= MaxTam)
cout << "Pilha cheia\n";
else
{
Pilha->Item[Pilha->Ultimo] = item;
Pilha->Ultimo++;
}
}

Pilha
Implementao alocao esttica pilha.cpp
tipoItem desempilha(TipoPilha* Pilha)
{
tipoItem v;
if (vazia(Pilha))
cout << "Pilha vazia.\n";
else
{
/* Retira elemento do topo */
v = Pilha->Item[Pilha->Ultimo-1];
Pilha->Ultimo--;
return v;
}
}
void libera(TipoPilha* Pilha)
{
delete(Pilha);
}
Pilha
Implementao alocao esttica main.cpp
#include <iostream>
#include "pilha.hpp"

using namespace std;

int main(int argc, char *argv[])
{
tipoPilha *pilha = inicializaPilha();

empilha(70, pilha);
empilha(60, pilha);
empilha(90, pilha);
empilha(50, pilha);

tipoItem item;

while (!vazia(pilha))
{
item = desempilha(pilha);
cout << "\nDesemplilhando... " << item << endl;
}

libera(pilha);

system("PAUSE");
return EXIT_SUCCESS;
}
Pilha
Implementao alocao dinmica pilha.hpp

#define tipoPilha struct TipoPilha
#define tipoItem int

tipoPilha* inicializaPilha();
int vazia(tipoPilha* Pilha);
void empilha(tipoItem item, tipoPilha* Pilha);
tipoItem desempilha(tipoPilha* Pilha);
void libera(tipoPilha* Pilha);
Pilha
Implementao alocao dinmica pilha.cpp
#include "pilha.hpp"
#include <iostream>

using namespace std;

struct TipoNodo
{
tipoItem item;
TipoNodo* Proximo;
};

struct TipoPilha
{
TipoNodo* Primeiro;
};
Pilha
Implementao alocao dinmica pilha.cpp

TipoPilha* inicializaPilha()
{
TipoPilha* pilha = new TipoPilha;
pilha->Primeiro = NULL;
return pilha;
}

int vazia(TipoPilha* Pilha)
{
return (Pilha->Primeiro == NULL);
}

TipoNodo* inicializaTipoNodo()
{
TipoNodo* x = new TipoNodo;
x->Proximo = NULL;

return x;
}


Pilha
Implementao alocao dinmica pilha.cpp

void empilha(tipoItem item, TipoPilha* Pilha)
{
TipoNodo* nodo = inicializaTipoNodo();
nodo->item= item;
nodo->Proximo = Pilha->Primeiro;
Pilha->Primeiro = nodo;
}


Pilha
Implementao alocao dinmica pilha.cpp

tipoItem desempilha(TipoPilha* Pilha)
{
tipoItem item;
if (vazia(Pilha))
cout << "Pilha vazia.\n";
else
{
item = Pilha->Primeiro->item;
TipoNodo* nodo = Pilha->Primeiro;
Pilha->Primeiro = Pilha->Primeiro->Proximo;
delete(nodo);
return item;
}
}
Pilha
Implementao alocao dinmica pilha.cpp

void libera(TipoPilha* Pilha)
{
TipoNodo* nodo = Pilha->Primeiro;
while (nodo != NULL)
{
TipoNodo* aux = nodo->Proximo;
delete(nodo);
nodo = aux;
}
delete(Pilha);
}
Pilha
Implementao alocao dinmica main.cpp
#include <iostream>
#include "pilha.hpp"

using namespace std;

int main(int argc, char *argv[])
{
tipoPilha *pilha = inicializaPilha();

empilha(70, pilha);
empilha(60, pilha);
empilha(90, pilha);
empilha(50, pilha);

tipoItem item;

while (!vazia(pilha))
{
item = desempilha(pilha);
cout << "\nDesemplilhando... " << item << endl;
}

libera(pilha);

system("PAUSE");
return EXIT_SUCCESS;
}
Pilha
Exemplo de aplicao -
Notao Polonesa Reversa
((1 + 2) * 4) + 3
1 2 + 4 * 3 + em notao
polonesa reversa
Utilizando uma pilha
consideramos:
empilhar quando encontrar um
operando;
desempilhar dois operandos e
achar o valor quando encontrar
uma operao.
empilhar o resultado.

Entrada Operao Pilha
1 Empilhar 1
2 Empilhar 1,2
+ Somar 3
4 Empilhar 3,4
* Multiplicar 12
3 Empilhar 12,3
+ Somar 15

Resultado final
Fila
Lista linear onde a operao de insero
ocorre no final da lista, e a de retirada no
final da lista:
O primeiro elemento inserido ser o primeiro a ser
retirado
O ltimo elemento inserido ser o ltimo a ser
retirado
Chamada FIFO (First In, First Out)
Aplicaes
Filas de espera em diversos domnios
Algoritmos para a representao de processos
que envolvem a partilha e distribuio de
recursos (timesharing).
Fila
Fila
Operaes bsicas
Criao
Destruio
Insero de um elemento
Remoo de um elemento
Localizao de um elemento para consulta
ou alterao da informao
Fila
Implementao alocao esttica fila.hpp
#define tipoFila struct TipoFila
#define tipoItem int

tipoFila* inicializaFila();
int vazia(tipoFila* Fila);
void enfileira(tipoItem item, tipoFila* Fila);
tipoItem desenfileira(tipoFila* Fila);
void libera(tipoFila* Fila);
Fila
Implementao alocao esttica fila.cpp
#include "fila.hpp"
#include <iostream>
#define MaxTam 1000

using namespace std;

struct TipoFila
{
tipoItem Item[MaxTam];
int Primeiro, Ultimo;
};
Fila
Implementao alocao esttica fila.cpp
TipoFila* inicializaFila()
{
TipoFila* fila = new (TipoFila);
fila->Primeiro = fila->Ultimo = 0;
return fila;
}

int vazia(TipoFila* fila)
{
return (fila->Primeiro == fila->Ultimo);
}
Fila
Implementao alocao esttica fila.cpp

void enfileira(tipoItem item, TipoFila* fila)
{
if (fila->Ultimo >= MaxTam)
cout << "Fila cheia\n";
else
{
fila->Item[fila->Ultimo] = item;
fila->Ultimo++;
}
}
Fila
Implementao alocao esttica fila.cpp
tipoItem desenfileira(TipoFila* fila)
{
tipoItem v;
if (vazia(fila))
cout << "Fila vazia.\n";
else
{
/* Retira elemento do incio da fila */
v = fila->Item[fila->Primeiro];
fila->Primeiro++;
return v;
}
}

Fila
Implementao alocao esttica fila.cpp

void libera(TipoFila* fila)
{
delete(fila);
}
Fila
Implementao alocao esttica main.cpp
#include <iostream>
#include "filaEstatica.hpp"

using namespace std;

int main(int argc, char *argv[])
{
tipoFila *fila = inicializaFila();

enfileira(70, fila);
enfileira(60, fila);
enfileira(90, fila);
enfileira(50, fila);

tipoItem item;

while (!vazia(fila))
{
item = desenfileira(fila);
cout << "\nDesenfileirando... " << item << endl;
}

libera(fila);

system("PAUSE");
return EXIT_SUCCESS;
}

Fila
Implementao alocao dinmica fila.hpp
#define tipoFila struct TipoFila
#define tipoItem int

tipoFila* inicializaFila();
int vazia(tipoFila* Fila);
void enfileira(tipoItem item, tipoFila* Fila);
tipoItem desenfileira(tipoFila* Fila);
void libera(tipoFila* Fila);
Fila
Implementao alocao dinmica fila.cpp
#include "fila.hpp"
#include <iostream>

using namespace std;

struct TipoNodo
{
tipoItem item;
TipoNodo* Proximo;
};

struct TipoFila
{
TipoNodo *Primeiro, *Ultimo;
};

Fila
Implementao alocao dinmica fila.cpp
TipoFila* inicializaFila()
{
TipoFila* fila = new TipoFila;
fila->Primeiro = fila->Ultimo = NULL;
return fila;
}

int vazia(TipoFila* Fila)
{
return (Fila->Primeiro == NULL);
}

TipoNodo* inicializaTipoNodo()
{
TipoNodo* x = new TipoNodo;
x->Proximo = NULL;

return x;
}

Fila
Implementao alocao dinmica fila.cpp
void enfileira(tipoItem item, TipoFila* Fila)
{
// insere item no fim da fila
TipoNodo *nodo = inicializaTipoNodo();
nodo->item = item;

if(vazia(Fila))
Fila->Primeiro = nodo;
else
Fila->Ultimo->Proximo = nodo;

Fila->Ultimo = nodo;
}
Fila
Implementao alocao dinmica fila.cpp

tipoItem desenfileira(TipoFila* Fila)
{
tipoItem v;
if (vazia(Fila))
cout << "Fila vazia.\n";
else
{
/* Retira elemento do incio da fila */
v = Fila->Primeiro->item;
TipoNodo* it = Fila->Primeiro;
Fila->Primeiro = Fila->Primeiro->Proximo;
delete(it);
return v;
}
}

Fila
Implementao alocao dinmica fila.cpp

void libera(TipoFila* Fila)
{
TipoNodo* nodo = Fila->Primeiro;
while (nodo != NULL)
{
TipoNodo* aux = nodo->Proximo;
delete(nodo);
nodo = aux;
}
delete(Fila);
}
Fila
Implementao alocao dinmica main.cpp
#include <iostream>
#include "fila.hpp"

using namespace std;

int main(int argc, char *argv[])
{
tipoFila *fila = inicializaFila();

enfileira(70, fila);
enfileira(60, fila);
enfileira(90, fila);
enfileira(50, fila);

tipoItem item;

while (!vazia(fila))
{
item = desenfileira(fila);
cout << "\nDesenfileirando... " << item << endl;
}

libera(fila);

system("PAUSE");
return EXIT_SUCCESS;
}