Coleção de Dados. Coleções de Dados Classificação 4/1/2011

(1)

Coleção de Dados



Um conjunto de dados(objetos), organizados(estruturados)

de alguma forma.



As coleções possuem operações padrão como: adicionar;



As coleções possuem operações padrão como: adicionar;

apagar; atualizar



As coleções são divididas em dois grandes grupos: Lineares

e Não-Lineares

 LINEARES – Neste tipo os objetos são ordenados pela sua posição,

ou seja, existe o primeiro objeto, segundo, terceiro, etc. Ex.: Vetor

 NÃO-LINEARES – Neste tipo não existe uma ordem em seus objetos.

Estrutura de Dados Prof. Flávio de Oliveira Silva, M.Sc.

Ex.: Árvore

8

Coleções de Dados

Classificação

Estrutura de Dados

(2)

Coleções Lineares



Considerando a forma de acesso aos objetos as coleções

lineares podem ser divididas em três tipos:

 ACESSO DIRETO

 ACESSO SEQÜENCIAL  ACESSO INDEXADO

Prof. Flávio de Oliveira Silva, M.Sc. 10

Coleções Lineares

Acesso Direto



Neste tipo de coleção linear o acesso aos objetos pode ser

feito em qualquer ordem



É possível obter o terceiro objeto diretamente sem a



É possível obter o terceiro objeto diretamente sem a

necessidade de obter o primeiro e em seguida do segundo.



Exemplos

 Obter elementos Vetor

 Selecionar uma música em um CD  Obter registros em um Arquivo



Estruturas de Dados



Estruturas de Dados

 Vetor (Array)  Arquivo (File)

(3)

Coleções Lineares

Acesso Sequencial



Neste tipo de coleção linear o acesso aos objetos pode ser

feito apenas em uma ordem seqüencial,



Para obter o terceiro objeto e necessário primeiramente



Para obter o terceiro objeto e necessário primeiramente

obter o primeiro e em seguida do segundo.



Exemplos

 Retirar um caminhão estacionado em uma garagem abaixo  Obter trechos de uma fita Vídeo

 Obter trechos de um arquivo de dados



Estruturas de Dados



Estruturas de Dados

 Lista (List)  Pilha (Stack)  Fila (Queue) 12

Coleções Lineares

Acesso Indexado



Neste tipo de coleção linear o acesso aos objetos é feito a

partir de uma chave.



A chave deve ser única no conjunto a fim de permitir que a



A chave deve ser única no conjunto a fim de permitir que a

busca seja eficiente

 Exemplos: CPF, Número Matrícula, Número Conta Bancária



Neste tipo de estrutura a chave pode estar armazenada

juntamente com o objeto.



Exemplo:

 Dicionário

Estrutura de Dados Prof. Flávio de Oliveira Silva, M.Sc.  Dicionário

 Lista Telefônica (Indexada por: número, Assinante, Categoria)



Estrutura de Dados

 Tabela Hash (Hash Table)  Dicionário (Dictionary)

(4)

Lista

Definição



Uma lista é uma coleção de objetos que possuem uma

relação de ordem entre si, ou seja, existe o primeiro;

segundo; etc.

a

₁

, a

₂

, a

₃

, ... , a

_n

n≥0



Uma lista pode ter 0 ou mais objetos



O número n é o TAMANHO da lista



Uma LISTA VAZIA não possui objetos.

U li t é dit HOMOGÊNEA

d t d

bj t

ã d



Um lista é dita HOMOGÊNEA quando todos objetos são do

mesmo tipo.

14

Lista

Estática



Utilizada para representar situações onde o número de

objetos é FIXO



Exemplos:



Exemplos:

 Uma lista contendo disjuntores em um painel(o número máximo é

fixo);

 Lista de equipamentos estocados em uma prateleira (o número de

prateleiras é fixo).

 Lista de cabines telefônicas em uso (o número de cabines é fixo);  Lista de passagens vendidas (o número de poltronas disponíveis é

fixo);

fixo); …

(5)

Lista

Dinâmica



Utilizada para representar situações onde o número de

elementos é variável, sendo que não é possível prever qual

será o número máximo de objetos.



Exemplos:

 Lista de circuitos de um painel (Cada painel poderá ter um número

qualquer de circuitos);

 Lista de equipamentos adquiridos;

 Lista de telefones instalados em uma localidade;  Lista de reservas feitas para um determinado vôo; …

Lista

Representação



Considerando que a lista é uma coleção de objetos onde existe

o primeiro, segundo, etc. Como podemos representá-la?



LISTA ESTÁTICA – Neste caso os objetos de uma lista estarão



LISTA ESTÁTICA Neste caso os objetos de uma lista estarão

contidos em um Vetor



LISTA DINÂMICA – Neste caso os objetos da lista são

alocados de forma dinâmica e um objeto qualquer deve

conhecer a posição do seu próximo objeto

conhecer a posição do seu próximo objeto.

(6)

Lista Estática

Representação



Para criar uma lista estática a partir de um vetor

necessitamos basicamente das seguintes informações:

 Um vetor que conterá os objetos da lista (listData)

 Este vetor irá conter um número máximo de objetos (MAXLISTSIZE)  O vetor irá utilizar um tipo genérico de dados (T)

 Um número inteiro que indicará o número de objetos existentes nesta

lista (size).

 Inicialmente o número de objetos é igual a zero.

 O número de objetos (size) deverá ser sempre menor ou igual que o

tamanho do vetor (MAXLISTSIZE)

 O primeiro objeto será inserido da posição 0 do vetor (listData)

18

Lista Estática

Pontos Fortes x Pontos Fracos



PONTOS FORTES

 Acesso direto indexado a qualquer objeto da lista

 Tempo constante para acessar o objeto i (depende somente do

índice.



PONTOS FRACOS

 Movimentação quando eliminado/ inserido objeto

 Tamanho máximo fixo, sendo necessário um conhecimento inicial

deste número



QUANDO UTILIZAR

 Em situações onde o tamanho máximo pode ser previsto  Em situações onde a lista não irá conter um grande número de

objetos.

(7)

Lista Estática

Representação (C++)



Lista será vista como uma classe



Classe Lista

 Contém dois atributos  Contém dois atributos

Tamanho

 int size;

Elementos

 T listData[MAXLISTSIZE];

 Classe fornecerá operações básicas sobre a lista  Representação UML _{class Domain Obj ects}

Prof. Flávio de Oliveira Silva, M.Sc. 20 List

- size: int

- listData[MAXLISTSIZE]: T

Lista Estática

Representação C padrão



Representada como uma struct



Struct List

 Contém dois membros  Contém dois membros

Tamanho  int size; Elementos  T listData[MAXLISTSIZE];  Representação C struct List { i t i Estrutura de Dados Prof. Flávio de Oliveira Silva, M.Sc. int size;

T listData[MAXLISTSIZE]; };

(8)

Lista

Operações



Qualquer objeto da lista pode ser recuperado e/ou

modificado



É possível a inserção de novos objetos na lista



É possível a inserção de novos objetos na lista



É possível a remoção de objetos da lista



Lista estática

 Algumas operações de inserção e remoção exigem um grande

esforço

 Necessitam da movimentação de todos os outros objetos existentes

na lista.

Lista – Operações

Recuperação e Modificação (C++)

 getSize – Retorna o número de elementos

int getSize(void) const;

 getFirst – Retorna o primeiro de elemento int getFirst(T& elem) const;

 getLast – Retorna o ultimo de elemento int getLast(T& elem) const;  getData – Retorna o i-ésimo elemento

int getData(int pos, T& elem) const; //(1 ≤ pos ≤ size)  setData – Altera o i-ésimo elemento

i t tD t (i t T l ) //(1 ≤ ≤ i )

int setData(int pos, T& elem); //(1 ≤ pos ≤ size)

 find – Encontra a primeira ocorrência bool find(T elem)const;

 Observação

 Todas as operações retornam 0 em caso de sucesso e diferente de zero em caso de erro

(9)

Lista – Operações

Recuperação e Modificação (C)

 getSize – Retorna o número de elementos

int getSize(struct List* l) const;  getFirst – Retorna o primeiro de elemento

int getFirst(struct List* l, T* elem) const;  getLast – Retorna o ultimo de elemento

int getLast(struct List* l, T* elem) const;  getData – Retorna o i-ésimo elemento

int getData(struct List* l, int pos, T* elem)//(1 ≤ pos ≤ size)  setData – Altera o i-ésimo elemento

i t tD t ( t t Li t* l i t T* l )//(1 ≤ ≤ i )

int setData(struct List* l, int pos, T* elem)//(1 ≤ pos ≤ size)  find – Encontra a primeira ocorrência

bool find(struct List* l, T elem)const;  Observação

 Todas as operações retornam 0 em caso de sucesso e diferente de zero em caso de erro

24

Lista – Operações

Inserção – Visão Geral



O primeiro elemento é inserido na posição 0 do vetor



O segundo a próxima posição (1) e assim sucessivamente



Para realizar a inserção em certos casos é necessária a



Para realizar a inserção, em certos casos, é necessária a

movimentação de todos os objetos existentes no vetor.



Inserção na i-ésima posição, sendo posição < size

(10)

Lista – Operações

Inserção

 insert - Insere um elemento no final da lista int insert(const T& elem);

 insertFirst - Insere um elemento no início da lista i t i tFi t( t T& l )

int insertFirst(const T& elem);

 insertLast Insere um elemento no final da lista int insertLast(const T& elem);

 insertAt - Insere um elemento em uma posição qualquer int insertAt(int pos, const T& elem);

 insertAfter - Insere um elemento após uma posição informada int insertAfter(int pos const T& elem)

Estrutura de Dados Prof. Flávio de Oliveira Silva, M.Sc. int insertAfter(int pos, const T& elem)

 insertBefore - Insere um elemento antes de uma posição int insertBefore(int pos, const T& elem)

 Observações

 O primeiro elemento está na posição 1 e assim sucessivamente ( 1 ≤ pos ≤ size)  Todas as operações retornam 0 em caso de sucesso e diferente de zero em caso de erro

26

Lista – Operações

Remoção



Da mesma forma que a inserção, a remoção em uma lista

estática necessita, em certos, casos da movimentação de

todos os elementos existentes na lista.



Dependendo do tamanho da lista, esta operação exige um

esforço computacional extra.



Remoção de um elemento da i-ésima posição (posição <

size)

(11)

Lista – Operações

Remoção

 remove - Remove a primeira ocorrência de um elemento int remove(const T&);

 removeFirst - Remove o primeiro elemento da lista int removeFirst(T& elem);

 removeLast - Remove o ultimo elemento da lista

int removeLast(T& elem);

 Remove um elemento em uma posição especificada

int removeAt(int pos, T& elem); //(1 ≤ pos ≤ size)  revomeAfter - Remove um elemento após uma posição informada

i t Aft (i t T& l ) //(1 ≤ ≤ i )

int removeAfter(int pos, T& elem); //(1 ≤ pos ≤ size)  removeBefore - Remove um elemento antes de uma posição

int removeBefore(int pos, T& elem); //(1 ≤ pos ≤ size)  Remove todos os elementos da lista

int removeAll();

28

Lista – Operações

Apoio

 isEmpty – Indica se a lista está (true) ou não (false) vazia bool isEmpty(void) const;

 isFull – Indica se a lista está (true) ou não (false) cheia bool isFull() const;

 print – Imprime o conteúdo da lista void print(void) const;

 moveRight – Move todos os elementos uma posição para a direita a partir

da posição da lista recebida

int moveRight(int pos);

 moveLeft Move todos os elementos uma posição para a esquerda a

 moveLeft – Move todos os elementos uma posição para a esquerda a

partir da posição da lista recebida

int moveLeft(int pos);  Observações

 O primeiro elemento está na posição 1 e assim sucessivamente ( 1 ≤ pos ≤ size)

(12)

Lista Estática

Definição – CPP (List.h)

# include <iostream> # define iMaxListSize 32 typedef int T; class List { private:

//Vetor que irá conter os objetos da lista T listData[ iMaxListSize];

//Número de objetos da lista int iSize;

public:

// constructor List(void);

List(void);

// Metodos Acessores

//Recupera o número de objetos da lista int getSize(void) const;

/Recupera a informação contida em uma determinada posição int getData(int, T&) const;

30

Lista Estática

Definição – CPP (List.h)

//Métodos Modificadores

//Altera o conteudo da lista em uma determinada posição void setData(int, T&);

//Insere um objeto no final da lista void insert(const T&);

//Remove a primeira ocorrência de um objeto da lista void remove(const T&);

//Remove o primeiro objeto da lista int removeFirst(const T&);

//Remove todos os objetos da lista void removeAll(void);

//Outros métodos

//Retorna um valor booleano indicando se a lista é o não vazia bool isEmpty(void) const;

//Encontra a primeira ocorrência de um objeto da lista bool find(T&) const ;

// imprime o conteudo da lista void print() const;

(13)

Lista Estática

Implementação – CPP (List.cpp)

# include <iostream> # include "List.h" using namespace std; List::List(void){

//Tamanho inicial da lista é zero iSize = 0;

}

// retorna o número de objetos da lista int List::getSize(void) const{

return iSize; }

Lista Estática

Implementação – CPP (List.cpp)

//Retorna o objeto existente em uma determinada posição da lista //Caso a posição seja inválida, retorna diferente de zero

int List::getData(int pos, T& elem) const { if (pos < 0 || pos >= iSize) {

cerr << "Posição inválida!!!" << endl; return 1;

}

elem = listData[pos]; return 0;

}

//Altera o conteudo da lista em uma determinada posição int List::setData(int pos, T& data) {

if (pos < 0 || pos >= iSize) {

cerr << "Posição inválida!!!" << endl; return 1;

}

listData[pos] = data; return 0;

(14)

Lista Estática

Implementação – CPP (List.cpp)

// Insere um objeto no final da lista int List::insert(const T& item){

//Caso o número de posições máximo tenha sido atingindo retorna if (iSize >= iMaxListSize){

cerr << "O tamanho máximo da lista foi atingido!" << endl; return 1;

}

// Insere um objeto no final da lista listData[ iSize] = item;

// Incrementa o número de objetos iSize++;

}

Lista Estática

Implementação – CPP (List.cpp)

// Procura por um item na lista e remove a primeira ocorrência int List::remove(const T& item) {

//Inicializa variável ii que será utilizada para percorrer a lista int ii(0);

// Procura por um objeto

while (ii < iSize && !(item == listData[ii] )) ii++;

//Caso ii seja igual ou maior que iSize, então não foi encontrado if (ii == iSize)

return 1;

//Decrementa o tamanho da lista iSize--;

// move os objetos seguintes da lista para esquerda uma posição, //ou seja o objeto da posição ii+1 será colocado na posição ii while (ii < iSize){

listData[ ii] = listData[ ii+1] ; ii++;

}

return 0; }

(15)

Lista Estática

Implementação – CPP (List.cpp)

// Verifica se a lista está vazia bool List::isEmpty(void) const {

if (iSize == 0) return true; else

return false; }

// Remove todos os objetos da lista void List::removeAll(void){

iSize = 0; }

Lista Estática

Implementação – CPP (List.cpp)

// Remove o primeiro objeto da lista e retorna o valor removido //Caso a posição seja inválida, o programa return diferente de zero int List::removeFirst(T& item) {

T frontItem;

// Caso a Lista esteja Vazia, finaliza o programa if (isEmpty()) {

cerr << "Erro! Lista vazia..." << endl; return 1;

}

//Recupera o primeiro objeto item = listData[0] ;

//Remove o primeiro objeto

remove(item);

// retorna o valor removido return 0;

}

(16)

Lista Estática

Implementação – CPP (List.cpp)

//Este método irá percorrer a lista a fim de encontrar o objeto item //Caso o mesmo não seja encontrado retorna false

bool List::find(T& item) const { int ii(0);

//Caso a lista seja vazia retorna false if (isEmpty())

return false;

//Procura pelo objeto na lista

while (ii < iSize && !(item == listData[ ii] )) ii++;

//Caso ii seja igual ao tamanho da lista, indica que o item //nao foi encontrado

if (ii == iSize) return false; return true; } 38

Lista Estática

Implementação – CPP (List.cpp)

//Imprime o conteúdo da lista void List::print()const {

int ii(0);

//Caso a lista seja vazia retorna if (isEmpty()){

cout << "Lista Vazia!" << endl; return;

}

cout << "Imprimindo o conteudo da lista..." << endl; while (ii < iSize){

cout << "objeto: " << ii << " - " << listData[ ii] << endl; ii++;

} }

(17)

Pilha (Stack)

 Uma pilha é uma coleção de objetos que possuem uma relação de ordem

entre si, ou seja, existe o primeiro; segundo; etc.

 Na pilha os objetos obedecem ao princípio "Último a entrar - Primeiro a

sair" LIFO (Last in First Out) sair" - LIFO (Last-in - First Out)

a1, a2, a3, ... , an n≥0

 Na pilha abaixo, o primeiro objeto a entrar foi o objeto a₁e o último o

objeto an, porém somente é possível a remoção do objeto an.

 Para remover o objeto a₁é necessário antes remover todos os outros

objetos e finalmente será possível sua remoção

 O objeto a_né conhecido como o topo da pilha

Pilha (Stack)



Uma pilha pode ter 0 ou mais elementos



Uma PILHA VAZIA não possui elementos.



Uma pilha pode ser implementada como uma lista onde



Uma pilha, pode ser implementada como uma lista onde

todas as inserções e remoções são feitas somente em uma

de suas extremidades.



O topo da pilha pode ser o último ou o primeiro objeto da

lista.

(18)

Pilha (Stack)

Estática x Dinâmica

 Assim como a lista a pilha pode ser representada de forma estática ou

dinâmica

 Pilha Estática

N t bj t d ilh t ã tid V t

 Neste caso os objetos da pilha estarão contidos em um Vetor

 Pilha Dinâmica

 Neste caso os objetos da pilha são alocados de forma dinâmica  Um elemento qualquer deve conhecer a posição do seu sucessor

Pilha (Stack) Estática

Representação

 Para criar uma pilha estática a partir de um vetor necessitamos

basicamente das seguintes informações:

 Um vetor que irá conter os objetos da pilha (stackData).

Este etor irá conter m número má imo de objetos (iMa StackSi e)  Este vetor irá conter um número máximo de objetos (iMaxStackSize)  O vetor irá utilizar um tipo genérico de dados (T)

 Um número inteiro que irá indicar o índice do TOPO da pilha (iTop).  Inicialmente o TOPO da pilha é igual a -1.

 O TOPO deverá ser sempre menor ou igual ao tamanho máximo do vetor (iMaxStackSize)

(19)

Pilha

Operações



É possível a inserção (push) de novos objetos no TOPO da

pilha



É possível a remoção (pop) somente do objeto que se



É possível a remoção (pop) somente do objeto que se

encontra no TOPO da pilha



Somente o objeto que está no TOPO da pilha pode ser

recuperado (peek)

Pilha – Operações

Inserção



push

 Insere um elemento no topo da pilha caso a mesma não esteja cheia  Retorna uma constante indicando sucesso ou falha

int push (const T& item)

(20)

Pilha – Operações

Remoção



pop

 Remove o objeto que se encontra no topo da Pilha

 Retorna o objeto removido e uma constante indicando sucesso ou falha int pop(T& item) – C++

int pop(struct Stack* s, T* item) – C



removeAll

 Remove todos os objetos que se encontram na Pilha void removeAll()

46

Pilha – Operações

Consulta e Recuperação

 peek

 Recupera o elemento que se encontra no TOPO na pilha, sem no entanto retirá-lo

 Retorna uma constante indicando sucesso ou falha que ocorre quando a  Retorna uma constante indicando sucesso ou falha que ocorre quando a

pilha está vazia, por exemplo

int peek(T& item)

Estrutura de Dados Prof. Flávio de Oliveira Silva, M.Sc.  getSize -Retorna o número de elementos na pilha

int getSize(void)

 find –Encontra a primeira ocorrência de um determinado objeto

bool find(T& item) const

(21)

Pilha – Operações

Métodos de Apoio



isEmpty

 Retorna um booleano indicando se a pilha está ou não vazia bool isEmpty(void) const;



isFull

 Retorna um booleano indicando se a pilha está ou não cheia bool isFull(void) const;



print

 Imprime o conteúdo da pilha Void print() const;

p () ; 48

Pilha

Definição - C

#define MAXSTACKDATA 10

typedef double T;

struct Stack {

T stackData[MAXSTACKDATA];

int iTop;

};

(22)

Pilha

Definição – C++

#define MAXSTACKDATA 10

template <class T> class Stack {

private:

T stackData[MAXSTACKDATA];

int iTop;

public:

//operacoes

p

};

50

Pilha

Definição – Pilha.h

# ifndef STACK_CLASS # define STACK_CLASS # include <iostream> # define iMaxStackSize 32 typedef int T; class Stack { private:

//Vetor que irá conter os elementos da pilha T stackData[ iMaxStackSize];

//Inteiro que indica o índice do topo da pilha int iTop;

int iTop; public:

//construtor Stack(void)

(23)

Pilha

Definição – Pilha.h

//Operações de Modificação

//Armazena um item na pilha no topo da pilha void push (const T&);

//Remove o topo da pilhap p T pop (void);

//Remove todos os objetos da pilha void removeAll(void);

//Operações de Consulta

// Obtém objeto que se encontra no topo da pilha sem modifica-lo T peek (void) const;

int getSize(void);

bool find(T& item) const;

bool find(T& item) const; //Métodos de Apoio

bool isEmpty(void) const; bool isFull(void) const; void print()const; }; #endif 52

Pilha

Implementação – Pilha.cpp

// Construtor do objeto pilha Stack::Stack (void){

iTop = -1 }

//Armazena um item na pilha no topo da pilha int Stack::push (const T& item){

// Verifica se a pilha está cheia, retorna constante indicando erro if (isFull()) {

cout << "A pilha está cheia!" << endl; return 1;

}

// incrementa o topo da pilha

// incrementa o topo da pilha iTop++;

//coloca o elemento no topo da pilha stackData[iTop] = item;

return 0; }

(24)

Pilha

Implementação – Pilha.cpp

//Remove o topo da pilha e o elemento que se encontra nesta posição int Stack::pop (T& elem) {

// Verifica se a pilha está vazia. Caso esteja retorna condição erro

if (isEmpty()) {

cout << "A pilha está vazia!" << endl; return 1;

}

// obtem o elemento que está no topo elem = stackData[ iTop] ;

//decrementa o topo da pilha iTop--;

p return 0; } 54

Pilha

Implementação – Pilha.cpp

// Obtem o objeto que se encontra no topo da pilha sem modificá-la int Stack::peek (T& item) const {

// Verifica se a pilha está vazia. Caso esteja o programa será finalizado

if (isEmpty()) {

cout << "A pilha está vazia!" << endl; return 1;

}

item = stackData[ iTop] ; return 0;

}

//Verifica se a pilha está vazia bool Stack::isEmpty(void) const {

// Retorna true ou false, dependendo do resultado da comparação return (iTop == -1);

}

(25)

Pilha

Implementação – Pilha.cpp

//Verifica se a pilha está cheia bool Stack::isFull(void) const {

// Retorna true ou false, dependendo do resultado da comparação return (iTop == iMaxStackSize-1);p

}

// Limpa a pilha

void Stack::removeAll(void) {

// Coloca o valor do topo como -1 iTop = -1;

}

Pilha

Implementação – Pilha.cpp

void Stack::print()const { //Começa a partir do topo int ii(iTop);

//Caso a pilha seja vazia retornap j if (isEmpty()){

cout << "Pilha Vazia!" << endl; return;

}

cout << "Imprimindo o conteudo da Pilha..." << endl; while (ii >= 0){

cout << "Elemento: " << ii << " - " << stackData[ ii] << endl; ii--;

ii ; } }

# endif //STACK_CLASS

(26)

Pilha

Implementação – Pilha.cpp

//Verifica se a pilha está cheia bool Stack::isFull(void) const {

// Retorna true ou false, dependendo do resultado da comparação return (iTop == iMaxStackSize-1);p

}

// Limpa a pilha

void Stack::removeAll(void) {

// Coloca o valor do topo como -1 iTop = -1;

}

Pilha

Implementação – Pilha.cpp

void Stack::print()const { //Começa a partir do topo int ii(iTop);

//Caso a pilha seja vazia retornap j if (isEmpty()){

cout << "Pilha Vazia!" << endl; return;

}

cout << "Imprimindo o conteudo da Pilha..." << endl; while (ii >= 0){

cout << "Elemento: " << ii << " - " << stackData[ ii] << endl; ii--;

ii ; } }

# endif //STACK_CLASS

(27)

Fila

 Uma fila é uma coleção de objetos que possuem uma relação de ordem

entre si, ou seja, existe o primeiro; segundo; etc.

 Porém na pilha os objetos obedecem ao princípio "Primeiro a entrar

-Primeiro a sair" FIFO (First in First Out) Primeiro a sair" - FIFO (First in – First Out)

a1, a2, a3, ... , an n≥0

 Na fila acima, o primeiro objeto a entrar foi o objeto a₁e o último a_n.  Somente é possível a remoção do objeto a1

 Da mesma forma, caso um novo objeto seja inserido na fila a sua posição

será n+1, visto que o último objeto que foi colocado na fila foi an

 O objeto a₁é conhecido como o início da fila

j ₁

 O objeto a_né conhecido como o final da fila

60

Fila

Definição



Uma fila pode ter 0 ou mais objetos



Uma FILA VAZIA não possui objetos.



Uma fila pode ser implementada como uma lista onde todas



Uma fila, pode ser implementada como uma lista onde todas

as inserções são feitas em uma extremidade e as remoções

são feitas somente na outra extremidade da fila

 Neste caso o INIICIO da fila pode ser o primeiro elemento da lista  O ÚLTIMO elemento da fila será o último da lista

(28)

Fila

Estática x Dinâmica

 Assim como a lista a fila pode ser representada de forma  estática ou dinâmica

 FILA ESTÁTICA

 Neste caso os objetos da fila estarão contidos em um Vetor

 FILA DINÂMICA

 Neste caso os objetos da fila são alocados de forma dinâmica  Elemento qualquer deve conhecer a posição do seu elemento

Fila Estática

Representação Inicial

 Informações necessárias para representar uma fila estática a partir de um

vetor:

 Um vetor que conterá os elementos da Fila (queueData).

Este etor irá conter m número má imo de elementos (MAXQUEUESIZE)  Este vetor irá conter um número máximo de elementos (MAXQUEUESIZE)  O vetor irá utilizar um tipo genérico de dados (T)

 A posição 0 indicará o INÍCIO da fila.

 Um número inteiro indicará a próxima posição disponível no vetor após o final da fila (iBack)

(29)

Representação Inicial Fila

Deficiências

 Da maneira como a fila está modelada a mesma apresenta deficiências.  Por exemplo, supondo que a fila possui um tamanho máximo de 1000

objetos e que esta cheia:

 Ao remover o objeto que está no TOPO da fila será necessário mover

todos os objetos

 Desta forma a implementação da fila é ineficiente, pois exige um maior

esforço computacional

64

Fila

Representação Melhorada

 A fim de melhorar a representação da fila, será acrescentado um novo

atributo no objeto.

 Neste caso será acrescentado um número inteiro (iFront) que indicará o INÍCIO da fila

INÍCIO da fila.

 Quando o objeto que está no início da fila for removido este valor será

atualizado, desta forma não será necessário movimentar os objetos

(30)

Fila – Representação Melhorada

Exemplo

 A última inserção – push(2) – não é possível, mesmo com posições

disponíveis no vetor. Como resolver isto?

66

Fila – Representação Final

Fila Circular

 A fim de resolver o problema anterior, será feita a seguinte modificação

na fila:

 Neste caso a fila irá se comportar de maneira circular ou seja:  Quando um novo elemento for inserindo última posição do vetor

(iMaxQueueSize-1) o valor de iBack será igual a zero, ou seja a primeira posição do vetor

p ç

 No exemplo a variação do iBack deveria ser da seguinte forma:

(31)

Fila – Representação Final

Fila Circular

 iBack deve comportar-se da seguinte forma:  0 1 2 3 4 0 1 2 3 4 0...

 Para isto será utilizado o operador módulo (%)  Módulo – Retorna o resto da divisão inteira  Exemplo: 5 % 5 = 0; 5 % MAXQUEUESIZE = 0

 Neste caso o incremento de iBack será da seguinte forma:  iBack = (iBack + 1) % MAXQUEUESIZE

 O mesmo comportamento será associado também a iFront

 iFront= (iFront + 1) % MAXQUEUESIZE

Fila – Representação Final

Fila Circular – Exemplo

 Sendo iMaxQueueSize = 6; iFront= 1; iBack= 5; Temos a seguinte

situação

 Ao inserir um novo elemento (8) teremos:

 Desta forma iBack e iFront vão variar de 0 a 5, podendo em seguida

voltar a 0

 Neste caso o vetor é preenchido de forma circular.

(32)

Fila Circular

Exemplo

Definição

Fila.h – C++

# ifndef QUEUE_CLASS # define QUEUE_CLASS # include <iostream>

//Tamanho Máximo de Elementos na fila //Tamanho Máximo de Elementos na fila const int MAXQUEUESIZE = 32;

template <class T> class Queue { private:

//vetor com fila e atributos int iFront, iBack, iSize; T queueData[MAXQUEUESIZE] ; bli

public:

//continua...

(33)

Definição

Fila.h – C++

//Construtor Queue (void);

//MODIFICAÇÃO (INSERÇÃO E REMOÇÃO) int push(const T& item);

int push(const T& item); int pop(T& item);

void removeAll(void); //RECUPERAÇÃO DA INFORMAÇÃO T getFront(void) const; T getBack(void) const; //MÉTODOS DE APOIO i t tSi ( id) t Estrutura de Dados Prof. Flávio de Oliveira Silva, M.Sc.

int getSize(void) const; int isEmpty(void) const; int isFull(void) const; };

# endif //QUEUE_CLASS

72

Fila Circular

Implementação – C++ (Fila.cpp)

// inicializa as variáveis membro da fila iFront, iBack, iSize template <class T> Queue<T>::Queue (void) {

iFront = 0; iBack = 0; iBack = 0; iSize = 0; }

// Recupera o objeto que está no inicio da fila template <class T> T Queue<T>::getFront(void) const {

return queueData[ iFront] ; }

// R bj t t fi l d fil

// Recupera o objeto que se encontra no final da fila template <class T> T Queue<T>::getBack(void) const {

return queueData[iBack] ; }

(34)

Fila Circular

Implementação – C++ (Fila.cpp)

//Recupera o número de elementos na fila

template <class T> int Queue<T>::getSize(void) const { return iSize;

} }

//Insere um elemento na fila

int template <class T> void Queue<T>::push (const T& item) { //Finaliza se a fila estiver cheia retorna 1, indicando erro if (isFull()){

return 1; }

// Incrementa iSize

// Incrementa iSize iSize++;

//Coloca o elemento na ultima posicao queueData[ iBack] = item;

//Atualiza iBack, indicando a ultima posição disponível iBack = (iBack+1) % iMaxQueueSize;

} 74

Fila Circular

Implementação – C++ (Fila.cpp)

// Remove um elemento da fila e retorna seu valor no parâmetro int template <class T> T Queue<T>::pop(T& item) {

// Retorna se a fila estiver vazia if (isEmpty()){

if (isEmpty()){ return 1; }

//Recupera o objeto que esta no inicio da fila e coloca em temp item = queueData[ iFront] ;

// Decrementa o tamanho da fila iSize--;

//Atualiza o inteiro que representa o inicio da fila avançando

//Atualiza o inteiro que representa o inicio da fila, avançando //uma posição

iFront = (iFront+1) % iMaxQueueSize; //Retorna indicando sucesso

return 0; }

(35)

Fila Circular

Implementação – C++ (Fila.cpp)

// Remove um elemento da fila e retorna seu valor no parâmetro int template <class T> T Queue<T>::pop(T& item) {

// Retorna se a fila estiver vazia if (isEmpty()){

if (isEmpty()){ return 1; }

//Recupera o objeto que esta no inicio da fila e coloca em temp item = queueData[ iFront] ;

// Decrementa o tamanho da fila iSize--;

//Atualiza o inteiro que representa o inicio da fila avançando

//Atualiza o inteiro que representa o inicio da fila, avançando //uma posição

iFront = (iFront+1) % iMaxQueueSize; //Retorna indicando sucesso

return 0; }

76

Fila Circular

Implementação – C++ (Fila.cpp)

//Verifica que a fila está vazia

template <class T> int Queue<T>::isEmpty(void) const {

//A fila está vazia quando iSize == 0 (número de objetos = 0) return iSize == 0;

return iSize 0; }

//Verifica que a fila está cheia

template <class T> int Queue<T>::isFull(void) const { //A fila está cheia quando iSize == iMaxQueueSize return iSize == iMaxQueueSize;

}

//Remove todos os objetos da fila

template <class T> void Queue<T>::removeAll(void) { iSize = 0;

iFront = 0; iBack = 0; }