EstruturaDados_Apost..

Universidade Federal de Uberlândia Faculdade de Computação Prof. Flávio de Oliveira Silva, M.Sc. Março de 2010 2 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação Sumário Lista de Figuras .............................................................................................................................................. 4 1. Introdução ............................................................................................................................................. 5 2. Coleção de Dados .................................................................................................................................. 5 3. 4. 5. 2.1 Coleções Lineares .......................................................................................................................... 5 2.2 Coleções Não Lineares .................................................................................................................. 5 2.3 Coleções Lineares – Formas de Acesso ......................................................................................... 6 Lista ....................................................................................................................................................... 8 3.1 Lista Estática .................................................................................................................................. 8 3.2 Lista Dinâmica ............................................................................................................................... 8 3.3 Representação da Lista ................................................................................................................. 8 3.4 Representação da Lista Estática .................................................................................................... 9 3.5 Operações sobre uma Lista ......................................................................................................... 10 3.6 Lista Estática – Implementação em C++ ..................................................................................... 13 Pilha ..................................................................................................................................................... 19 4.1 Pilha Estática e Dinâmica ............................................................................................................ 19 4.2 Representação da Pilha Estática ................................................................................................. 20 4.3 Operações sobre a Pilha.............................................................................................................. 21 4.4 Pilha Estática – Implementação em C++ ..................................................................................... 23 Fila ....................................................................................................................................................... 27 5.1 Fila Estática e Dinâmica ............................................................................................................... 28 5.2 Representação da Fila Estática ................................................................................................... 28 5.3 Operações sobre Fila Estática ..................................................................................................... 32 5.4 Fila Estática ‐ Implementação em C++ ........................................................................................ 32 3 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação Lista de Figuras Figura 1 ‐ Classificação das Estruturas de Dados .......................................................................................... 5 Figura 2 ‐ Acesso Direto ................................................................................................................................ 6 Figura 3 ‐ Acesso Sequencial ......................................................................................................................... 6 Figura 4 ‐ Acesso Indexado ........................................................................................................................... 7 Figura 5 ‐ Representação Lista Estática versus Dinâmica ............................................................................. 8 Figura 6 ‐ Representação da Lista Estática .................................................................................................... 9 Figura 7 ‐ Representação UML da Lista Estática ........................................................................................... 9 Figura 8 ‐ Representação da Lista Estática em C......................................................................................... 10 Figura 9 ‐ Inserção com Movimentação ...................................................................................................... 11 Figura 10 ‐ Remoção do i‐ésimo objeto ...................................................................................................... 12 Figura 11 ‐ Atributos Classe List (List.h) ...................................................................................................... 13 Figura 12 ‐ Métodos Classe List (List.h) ....................................................................................................... 14 Figura 13 ‐ Operações de Consulta e Alteração (List.cpp) .......................................................................... 15 Figura 14 ‐ Operações de Inserção e Remoção (List.cpp) ........................................................................... 16 Figura 15 ‐ Operações de Remoção e Apoio (List.cpp) ............................................................................... 17 Figura 16 ‐ Operações de Apoio (List.cpp) .................................................................................................. 18 Figura 17 ‐ Definição Pilha .......................................................................................................................... 19 Figura 18 ‐ Pilha Estática e Dinâmica .......................................................................................................... 20 Figura 19‐ Representação da Pilha Estática ................................................................................................ 20 Figura 20 ‐ Representação da Lista Estática em C ...................................................................................... 20 Figura 21 ‐ Representação da Pilha Estática em C ..................................................................................... 21 Figura 22 ‐ Inserção na pilha (push) ............................................................................................................ 21 Figura 23 ‐ Remoção da Pilha (pop) ............................................................................................................ 22 Figura 24 ‐ Recuperação do Topo (peek) .................................................................................................... 23 Figura 25 ‐ Definição de Atributos e Métodos da Pilha (stack.h) ............................................................... 24 Figura 26 ‐ Operações de Consulta e Inserção (Stack.cpp) ......................................................................... 25 Figura 27 ‐ Operações de Apoio e Remoção (Stack.cpp) ............................................................................ 26 Figura 28 ‐ Operações de Apoio (Stack.cpp) ............................................................................................... 27 Figura 29 ‐ FIla Estática e Dinâmica ............................................................................................................ 28 Figura 30 ‐ Representação Inicial da Fila Estática ....................................................................................... 28 Figura 31 ‐ Deficiência da Representação Inicial da Fila ............................................................................. 29 Figura 32 ‐ Representação Melhorada da Fila ............................................................................................ 29 Figura 33 ‐ Efeito Colateral da Representação Melhorada ......................................................................... 30 Figura 34 ‐ Representação da Fila de forma Circular .................................................................................. 31 Figura 35 ‐ Exemplo de Inserção na Fila Circular ........................................................................................ 31 Figura 36 ‐ Definição de Atributos e Métodos da Fila (Queue.h) ............................................................... 32 Figura 37 ‐ Operações de Consulta, Alteração e Inserção (Queue.cpp) ..................................................... 33 Figura 38 ‐ Operações de Remoção e Apoio (Queue.cpp) .......................................................................... 33 4 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 1. Introdução O entendimento das várias estruturas de dados disponíveis é um ponto central no desenvolvimento de soluções computacionais a vários problemas do mundo real. As estruturas de dados representam maneiras de se organizar os dados (objetos) manipulados por um programa. Geralmente um programa faz uso de diferentes estruturas de dados que são utilizadas conforme sua necessidade e aplicabilidade. Neste curso as estruturas de dados serão estudas como objetos. 2. Coleção de Dados Uma coleção de dados é um conjunto de dados, ou objetos, organizados, ou podemos dizer: estruturados, de alguma forma. 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 2.1
Figura 1 ‐ Classificação das Estruturas de Dados
Coleções Lineares Neste tipo os objetos são ordenados pela sua posição, ou seja, existe o primeiro objeto, segundo, terceiro etc. Um exemplo seria o vetor, comumentee presente em qualquer linguagem de programação. 2.2
Coleções Não Lineares Neste tipo não existe uma ordem em seus objetos. Um exemplo seria uma árvore. 5 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 2.3
Coleções Lineares – Formas de Acesso Considerando a forma de acesso aos objetos as coleções lineares podem ser divididas em três tipos: 


Acesso Direto Acesso Sequencial Acesso Indexado 2.3.1 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 necessidade de obter o primeiro e em seguida do segundo. É possível encontrar este tipo de acesso nas seguintes situações: 



Obter elementos Vetor Selecionar uma música em um CD Obter registros em um Arquivo Estruturas de Dados Exemplosde estruturas de dados com acesso direto: 

Figura 2 ‐ Acesso Direto Vetor (Array) Arquivo (File) 2.3.2 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 obter o primeiro e em seguida do segundo. É possível encontrar este tipo de acesso nas seguintes situações: 


Retirar um caminhão estacionado em uma garagem abaixo Obter trechos de uma fita Vídeo Obter trechos de um arquivo de dados Exemplos de estruturas de dados, que utilizam esta forma de acesso: 


Figura 3 ‐ Acesso Sequencial
Lista (List) Pilha (Stack) Fila (Queue) 6 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 2.3.3 Acesso Indexado Neste tipo de coleção linear o acesso aos objetos é feito a partir de uma chave. Neste caso, a chave deve ser única no conjunto a fim de permitir que a busca seja eficiente.. Como exemplos de chave pode‐se citar: 


Número de CPF Número Matrícula Número Conta Bancária Neste caso além do armazenamento do objeto em si, que é o interesse, é necessário armazenar a sua chave. Como exemplo de situações do mundo real onde esta estratégia de organização é utilizada pode‐se citar: 

Dicionário Lista Telefônica, com seções indexadas por nome do assinante e categoria Exemplos de estruturas de dados, que utilizam esta forma de acesso: 

Tabela Hash (Hash Table) Dicionário (Dictionary) Figura 4 ‐ Acesso Indexado
7 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 3. Lista Uma lista é uma coleção de objetos que possuem uma relação de ordem entre si, ou seja, existe o primeiro; segundo; etc. a1, a2, a3, ... , an n=0 Uma lista pode ter zero (0) ou mais objetos. O valor n é conhecimento como o tamanho da lista. Caso a lista não possua objetos a mesma é conhecimda como uma lista vazia. Uma lista homogênea é aquela em que todos os objetos são do mesmo tipo. 3.1
Lista Estática Utilizada para representar situações onde o número de objetos é fixo. Uma estrutura de dados deste tipo poderia ser utilizada na modelagem das seguintes situações: 



Llista contendo disjuntores em um painel Lista de equipamentos estocados em uma prateleira Lista de cabines telefônicas em uso Lista de passagens vendidas em um avião 3.2
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. As seguintes situações poderiam ser modeladas com uma estrutura de dados deste tipo: 



Lista de circuitos de um painel Lista de equipamentos adquiridos Lista de telefones instalados em uma localidade Lista de reservas feitas para um determinado vôo 3.3
Representação da Lista Considerando que a lista é uma coleção de objetos onde existe o primeiro, segundo etc. Qual a estratégia a ser utilizada para sua implementação? No caso da Lista Estática, os seus objetos estarão contidos em um Vetor. Já para a lista dinâmica os objetos da lista serão alocados de forma dinâmcia e um objeto qualquer deve conhecer o endereço do seu próximo objeto. Figura 5 ‐ Representação Lista Estática versus Dinâmica
Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 8 3.4
Representação da Lista Estática 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) Um inteiro (size) que conterá o número de objetos da lista em um dado momento O vetor conterá um um número máximo de objetos (MAXLISTSIZE) e utilizará um tipo genérico de dados (T). O número de objetos (size) deverá ser sempre menor ou igual que o tamanho do vetor (MAXLISTSIZE) e inicialmente seu valor zerá igual a zero. O primeiro objeto será inserido da posição 0 do vetor (listData). Figura 6 ‐ Representação da Lista Estática
3.4.1 Representação em C++ A lista será definida como uma uma classe. A classe List conterá dois atributos: 

Tamanho ‐ int size; Elementos ‐ T listData[MAXLISTSIZE]; A figura abaixo mostra a representação UML dos atributos da classe List class Domain Obj ects
List
-
size: int
listData[MAXLISTSIZE]: T
Figura 7 ‐ Representação UML da Lista Estática
9 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 3.4.2 Representação em C Neste caso a lista será uma estrutura que conterá dois campos: o vetor com os elementos e o inteiro que representa o tamanho da lista. A figura abaixo mostra como é a definição da estrutura. typedef double T;
struct List {
T listaData[MAXLISTSIZE];
int size;
}; Figura 8 ‐ Representação da Lista Estática em C
3.5
Operações sobre uma Lista A função de uma estrutura de dados é organizar os objetos segundo um critério. Esta organização permite a construção de operações a fim de manipular estes objetos facilitando a modificação e a recuperação dos dados. No caso da lista é possível tanto a inserção, a alteração e a remoção de objetos. A lista é bem flexível e permite que as operações ocorram em qualquer ponto da mesma. Algumas operações de inserção e remoçao exigem um grande esforço já que necessitarão que outros objetos existentes na lista sejam movimentados. 3.5.1 Recuperação e Modificação Neste caso as operações permitem recuperar informações sobre os elementos armazenados na lista, bem como alterar estes elementos. Em todos estes casos o tamanho da lista permanece inalterado. Em todas as operações abaixo as mesmas retornam um código inteiro cujo valor é zero (0) em caso de sucesso ou diferente de zero em caso de falha. 


getSize – Retorna o número de elementos o int getSize(void) const;
getFirst – Retorna o primeiro de elemento o int getFirst(T& elem) const;
getLast – Retorna o ultimo de elemento o int getLast(T& elem) const;
10 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 


getData – Retorna o i‐ésimo elemento o int getData(int pos, T& elem) const; //(1 ≤ pos ≤ size)
setData – Altera o i‐ésimo elemento o int setData(int pos, T& elem); //(1 ≤ pos ≤ size)
find – Encontra a primeira ocorrência do elemento o bool find(T elem)const;
3.5.2 Inserção Estas operações incrementam o tamaho da lista. Inicialmente a lista é vazia e não contém elementos, logo seu tamanho é igual a zero (0). O primeiro elemento é inserido na posição 0 do vetor, o segundo na próxima posição disponível, no caso um (1) e assim sucessivamente. Para realizar a inserção, em certos casos, é necessária a movimentação de todos os objetos existentes no vetor. A inserção sempre provocará movimentações quando um elemento for inserido na i‐ésima posição (pos) sendo: pos < size. A movimentação pode ser representada da seguinte forma: Figura 9 ‐ Inserção com Movimentação
Como anteriormete, todas as operações abaixo retornam um código inteiro cujo valor é zero (0) em caso de sucesso ou diferente de zero em caso de falha. As posições na lista são numeradas a partir de um (1), logo o primeiro elemento está na poisção um (1) e o último elemento está na posição que corresponde ao tamanho da lista (size). 





insert ‐ Insere um elemento no final da lista o int insert(const T& elem);
insertFirst ‐ Insere um elemento no início da lista o int insertFirst(const T& elem);
insertLast Insere um elemento no final da lista o int insertLast(const T& elem);
insertAt ‐ Insere um elemento em uma posição qualquer o int insertAt(int pos, const T& elem);
insertAfter ‐ Insere um elemento após uma posição informada o int insertAfter(int pos, const T& elem);
insertBefore ‐ Insere um elemento antes de uma posição o int insertBefore(int pos, const T& elem);
11 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 3.5.3 Remoção Da mesma forma que a inserção, a remoção de objetos 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. A remoção sempre provocará movimentações quando um elemento for inserido na i‐ésima posição (pos) sendo: pos < size. A movimentação neste caso pode ser representada da seguinte forma: Figura 10 ‐ Remoção do i‐ésimo objeto
Todas as operações abaixo retornam um código inteiro cujo valor é zero (0) em caso de sucesso ou diferente de zero em caso de falha. 






remove ‐ Remove a primeira ocorrência de um elemento o int remove(const T&);
removeFirst ‐ Remove o primeiro elemento da lista o int removeFirst(T& elem);
removeLast ‐ Remove o ultimo elemento da lista o int removeLast(T& elem);
Remove um elemento em uma posição especificada o int removeAt(int pos, T& elem); //(1 = pos = size)
revomeAfter ‐ Remove um elemento após uma posição informada o int removeAfter(int pos, T& elem); //(1 = pos = size)
removeBefore ‐ Remove um elemento antes de uma posição o int removeBefore(int pos, T& elem); //(1 = pos = size)
Remove todos os elementos da lista o int removeAll();
3.5.4 Operações de Apoio Além das operações básicas algumas operações básicas, algumas operações comuns a vários métodos podem ser definidas a fim de serem utilizadas, evitando que código comun seja repetido nas operações acima. 12 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 




isEmpty – Indica se a lista está (true) ou não (false) vazia o bool isEmpty(void) const;
isFull – Indica se a lista está (true) ou não (false) cheia o bool isFull() const;
print – Imprime o conteúdo da lista o void print(void) const;
moveRight – Move todos os elementos uma posição para a direita a partir da posição da lista recebida o int moveRight(int pos);
moveLeft – Move todos os elementos uma posição para a esquerda a partir da posição da lista recebida o int moveLeft(int pos);
3.6
Lista Estática – Implementação em C++ A implementação da lista estática pode ser dividada em dois arquivos. Um deles, chamado “List.h” conterá a definição da classe. Já o arquivo “List.cpp” possuirá a implementação de todas as operações listadas anteriormente. # 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);
// 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;
Figura 11 ‐ Atributos Classe List (List.h)
13 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação //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 caso a lista não seja 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;
};
Figura 12 ‐ Métodos Classe List (List.h)
A seguir é mostrada a implementação de alguns métodos da classe List. A fim de facilitar a implementação os métodos de apoio serão utilizados. Normalmente nas operações de inserção é necessário verificar se a lista não está cheia e em operações de remoção se a mesm não está vazia. Outro comportamento comum que deve ser realizado a movimentação à direita durante as operações de inclusão e à esquerda durante as operações de remoção. 14 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação # 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;
}
//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;
}
Figura 13 ‐ Operações de Consulta e Alteração (List.cpp)
15 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação // 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++;
}
// 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;
}
Figura 14 ‐ Operações de Inserção e Remoção (List.cpp)
Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 16 // Remove todos os objetos da lista
void List::removeAll(void){
iSize = 0;
}
// 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...”
return 1;
<< endl;
}
//Recupera o primeiro objeto
item = listData[0] ;
//Remove o primeiro objeto
remove(item);
// retorna o valor removido
return 0;
}
// Verifica se a lista está vazia
bool List::isEmpty(void) const {
if (iSize == 0)
return true;
else
return false;
}
Figura 15 ‐ Operações de Remoção e Apoio (List.cpp)
Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 17 //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;
}
//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++;
}
}
Figura 16 ‐ Operações de Apoio (List.cpp)
Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 18 4. Pilha Uma pilha é uma coleção de objetos que possuem uma relação de ordem entre si, ou seja, existe o primeiro; segundo; etc. Até aqui esta definição equivale a uma lista. a1, a2, a3, ... , an n ≥ 0 Na pilha, porém, os objetos obedecem ao princípio "Último a entrar ‐ Primeiro a sair", ou como é comumente conhecido, LIFO (Last‐in ‐ First Out). Desta forma as operações que modificam o tamanho dos objetos da pilha necessitam respeitar este princípio. Na pilha, mostrada acima, o primeiro objeto a entrar foi o objeto a1 e o último o objeto an, porém somente é possível a remoção do objeto an. Para remover o objeto a1 é necessário antes remover todos os outros objetos e finalmente será possível sua remoção. O objeto an é conhecido como o topo da pilha. Figura 17 ‐ Definição Pilha
Uma pilha pode ter zero (0) ou mais elementos. No caso de não conter elementos é dito que a pilha está vazia. 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. Neste caso, o topo da pilha pode ser o último ou o primeiro objeto da lista. 4.1
Pilha Estática e Dinâmica Assim como a lista a pilha pode ser representada de forma estática ou dinâmica. No caso da pilha Estática, seus objetos estarão contidos em um vetor, semelhante à estratégia utilizada na lista estática. Ja na pilha dinâmica, os objetos são alocados em tempo de execução e neste caso um elemento deve conhecer o endereço do seu sucessor. 19 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação Figura 18 ‐ Pilha Estática e Dinâmica
4.2
Representação da Pilha Estática A pilha estática pode ser representada, assim como a lista, a partir de um vetor. Neste caso são necessárias, basicamente as seguintes informações: 

Um vetor que conterá os objetos da pilha (stackData). Um número inteiro que irá indicar o índice do TOPO da pilha (iTop). O vetor conterá um um número máximo de objetos (MAXSTACKSIZE) e utilizará um tipo genérico de dados (T). O topo da pilha (iTop) deverá ser sempre menor ou igual que o tamanho do vetor (MAXSTACKSIZE) e inicialmente seu valor zerá igual a ‐1. O primeiro objeto será inserido na posição zero (0) do vetor (stackData). Figura 19‐ Representação da Pilha Estática
4.2.1 Representação em C++ A pilha será definida como uma uma classe. A classe Stack conterá dois atributos: 

Posição do topo ‐ int iTop; Elementos ‐ T listData[MAXSTACKSIZE]; 4.2.2 Representação em C Neste caso a pilha será uma estrutura que conterá dois campos: o vetor com os elementos e o inteiro que representa a posição do topo da pilha. A figura abaixo mostra como é a definição da estrutura. 20 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação typedef double T;
struct Stack {
T stackData[MAXSTACKSIZE];
int iTop;
}; Figura 21 ‐ Representação da Pilha Estática em C
4.3
Operações sobre a Pilha Considerando a politica de inserção é remoção de objetos da pilha o número de operações possíveis e bem mais restrito ao se comparar com a lista. É possível a inserção (push) de novos objetos no TOPO da pilha. Além disso é possível a remoção (pop) somente do objeto que se encontra no TOPO da pilha. Finalmente é possível recuperar (peek) qual objeto está no topo da pilha. 4.3.1 Inserção A operação de inserção, insere um elemento no topo da pilha caso a mesma não esteja cheia. Esta operação é conhecida como “push”. A mesma retorna uma constante indicando sucesso ou falha o
int push (const T& item) A figura a seguir mostra o comportamento desta operação. Figura 22 ‐ Inserção na pilha (push)
21 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 4.3.2 Remoção A operação de remoção, remove o objeto que se encontra no topo da Pilha. Esta operação é conhecida como “pop”. A mesma retorna uma constante indicando sucesso ou falha o
int pop(T& item)
Figura 23 ‐ Remoção da Pilha (pop)
Um outra operação possível seria aquele que provoca a remoção de todos os objetos da pilha. A mesma seria utilizada em momento em os objetos da pilha nao são mais necessários do ponto de vista lógico, pois fisicamente os mesmos continuarão armazenados no vetor. Esta operação poderia ser definida como chamadas sucessivas à operação de remoçao, ou mais, de modo mais simples, como uma reinicialização do valor do topo da pilha (iTop) que voltaria ao seu valor incial. 
removeAll ‐ Remove todos os objetos que encontram‐se na Pilha o void removeAll()
4.3.3 Consulta e Recuperação Algumas operações podem ser definidas a fim de permitir a consulta de informações sobre a pilha. A primeira operação conhecida como “peek” permite recuperar o elemento que encontra‐se no topo da pilha, sem no entendo retirá‐lo. Esta operação retorna uma constante indicando sucesso ou falha que ocorre, por exempo, quando a pilha está vazia o
int peek(const T& item)
22 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação Figura 24 ‐ Recuperação do Topo (peek)
Além disso as seguintes operações podem ser definidas: 

getSize ‐ Retorna o número de elementos na pilha o int getSize(void)const;
find – Encontra a primeira ocorrência de um determinado objeto o bool find(T& item) const;
4.3.4 Operações de Apoio Além das operações básicas algumas operações básicas, algumas operações comuns a vários métodos podem ser definidas a fim de serem utilizadas, evitando que código comun seja repetido nas operações acima. 


isEmpty ‐ Retorna um booleano indicando se a pilha está ou não vazia o bool isEmpty(void) const;
isFull ‐ Retorna um booleano indicando se a pilha está ou não cheia o bool isFull(void) const;
print ‐ Imprime o conteúdo da pilha o Void print() const;
4.4
Pilha Estática – Implementação em C++ A implementação da pilha estática pode ser dividada em dois arquivos. Um deles, chamado “Stack.h” conterá a definição da classe. Já o arquivo “Stack.cpp” possuirá a implementação de todas as operações apresentadas anteriormente. 23 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação # ifndef STACK_H
# define STACK_H
# include <iostream>
# define iMaxStackSize 32
template <class 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;
public:
//construtor
Stack(void)
//Operações de Modificação
//Armazena um item na pilha no topo da pilha
void push (const T&);
//Remove o topo da pilha
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;
//Métodos de Apoio
bool isEmpty(void) const;
bool isFull(void) const;
void print()const;
};
#endif // STACK_H
Figura 25 ‐ Definição de Atributos e Métodos da Pilha (stack.h)
24 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação # ifndef STACK_CLASS
# define STACK_CLASS
// Construtor do objeto pilha
template <class T> Stack::Stack (void){
iTop = -1
}
//Armazena um item na pilha no topo da pilha
template <class T> int Stack::push (const T& item){
// Verifica se a pilha está cheia, retorna constante indicando
erro
if (isFull()) {
return 1;
}
// incrementa o topo da pilha
iTop++;
//coloca o elemento no topo da pilha
stackData[iTop] = item;
return 0;
}
//Remove o topo da pilha e o elemento que se encontra nesta
posição
template <class T> int Stack::pop (T& elem) {
// Verifica se a pilha está vazia. Caso esteja retorna
condição erro
if (isEmpty()) {
return 1;
}
// obtem o elemento que está no topo
elem = stackData[ iTop] ;
//decrementa o topo da pilha
iTop--;
return 0;
}
Figura 26 ‐ Operações de Consulta e Inserção (Stack.cpp)
25 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação // Obtem o objeto que se encontra no topo da pilha sem modificá la
template <class T> 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
template <class T> bool Stack::isEmpty(void) const {
// Retorna true ou false, dependendo do resultado da
comparação
return (iTop == -1);
}
//Verifica se a pilha está cheia
template <class T> bool Stack::isFull(void) const {
// Retorna true ou false, dependendo do resultado da
comparação
return (iTop == iMaxStackSize-1);
}
// Limpa a pilha
template <class T> void Stack::removeAll(void) {
// Coloca o valor do topo como -1
iTop = -1;
}
Figura 27 ‐ Operações de Apoio e Remoção (Stack.cpp)
26 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação void Stack::print()const {
//Começa a partir do topo
int ii(iTop);
//Caso a pilha seja vazia retorna
if (isEmpty()){
cout << "Pilha Vazia!" << endl;
return;
}
cout << "Imprimindo o conteudo da Pilha..." << endl;
while (ii >= 0){
cout << "Elemento: " << ii << " - " << stackData[ ii] <<
endl;
ii--;
}
}
# endif //STACK_CLASS
Figura 28 ‐ Operações de Apoio (Stack.cpp)
5. Fila Uma fila é uma coleção de objetos que possuem uma relação de ordem entre si, ou seja, existe o primeiro; segundo etc. a1, a2, a3, ... , an n≥0 Na fila, porém, os objetos obedecem ao princípio "Primeiro a entrar ‐ Primeiro a sair", ou como é comumente conhecido, FIFO (First‐in ‐ First Out). Desta forma as operações que modificam o tamanho dos objetos da pilha necessitam respeitar este princípio Na fila, mostrada acima, o primeiro objeto a entrar foi o objeto a1 e o último o objeto an, porém somente é possível a remoção do objeto a1. Para remover o objeto an é necessário antes remover todos os outros objetos e finalmente será possível sua remoção. 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 inserido na fila foi an O objeto a1 é conhecido como o início da fila e o objeto an é conhecido como o final da fila 27 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação Caso a fila não contenha objetos, seu tamanho é igual a zero (0) e neste caso a fila é conhecida como uma fila vazia. A 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 início da fila pode ser o primeiro elemento da lista e o último elemento da fila será o último elemento da lista. 5.1
Fila Estática e Dinâmica A lista pode ser representada de forma estática ou dinâmica. No caso da lista estática, seus objetos estarão contidos em um vetor, semelhante à estratégia utilizada na lista estática. Ja na fila dinâmica, os objetos são alocados em tempo de execução e neste caso um elemento deve conhecer o endereço do seu sucessor. Figura 29 ‐ FIla Estática e Dinâmica
5.2
Representação da Fila Estática Considerando que a fila estática é muito semelhante à lista, podemos utilizar a mesma estratégia para sua presentação. 5.2.1 Representação Inicial Neste caso será utilizado para representar a fila: 

Um vetor que conterá os elementos da Fila (queueData). Um número inteiro indicará a próxima posição disponível no vetor após o final da fila (iBack) O vetor conterá um um número máximo de objetos (MAXQUEUESIZE) e utilizará um tipo genérico de dados (T). O próxima posição livre da fila (iT iBack op) deverá ser sempre menor ou igual que o tamanho do vetor (MAXQUEUESIZE) e inicialmente seu valor zerá igual a 0. O primeiro objeto será inserido na posição zero (0) do vetor (queueData). Figura 30 ‐ Representação Inicial da Fila Estática
28 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 5.2.2 Representação Inicial ‐ Deficiências Da maneira como a fila está modelada a mesma apresenta deficiências. Considere, por exemplo, que a fila possui um tamanho máximo de hum mil (1000) objetos e que esta cheia. Ao remover o objeto que está no inicio da fila será necessário mover todos os objetos uma posição para a direita. Figura 31 ‐ Deficiência da Representação Inicial da Fila
Desta forma a implementação da fila é ineficiente, pois exige um maior esforço computacional 5.2.3 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á a posição no vetor do início da fila. Desta forma, quando o objeto que está no início da fila for removido este valor será atualizado, evitando a movimentação dos objetos no vetor. Figura 32 ‐ Representação Melhorada da Fila
29 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 5.2.4 Representação Melhorada – Efeito Coleteral Indesejável A fim de melhorar a representação da fila, Isto resolverá o problema da movimentação, porém seu uso acarretará o seguinte efeito colateral no comportamento da fila. A medida que os objetos forem removidos as posições liberadas não estarão mais disponíveis. Figura 33 ‐ Efeito Colateral da Representação Melhorada
No exemplo mostrado na Figura 33 a última inserção desejada – push(2) – não pode ocorrer visto que a posição disponível está fora dos limites do vetor. Deve ser notado que à esquerdas existem posições livres, visto que o valor da posição do início da fila (iFront) possui o valor três (3). A representação melhorada necessita então de um ajuste a fim de permitir que as posições disponíveis no vetor sejam utilizadas. 5.2.5 Representação Final – Fila Circular A fim de resolver o efeito colateral anterior, será feita a seguinte modificação no comportamento da fila: Caso a última posição livre seja igual ao tamanho do máximo do vetor (MAXQUEUESIZE) e existam posições livres e a fila não esteje cheia, então, a próxima posição livre (iBack) assumirá o valor zero (0), conforme mostrado na Figura 34. 30 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação Figura 34 ‐ Representação da Fila de forma Circular
Neste caso iBack sofrerá uma variação de 0 a n‐1. Podemos dizer que neste caso a fila será vista como um círculo sendo possível que o seu inicio esteja em uma posição maior que a sua posição final. Pelo exemplo da Figura 34 pode‐ser perceber que iBack deve comportar‐se da seguinte forma: 0 1 2 3 4 0 1 2 3 4 0...
Para adicionar este comportamento será utilizado o operador módulo (%) 
Módulo – Retorna o resto da divisão inteira o Exemplo: 5 % 5 = 0; 5 % MAXQUEUESIZE = 0 Sendo assim 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 Por exemplo: Sendo iMaxQueueSize = 6; iFront= 1; iBack= 5. Ao inserir um novo elemento (8) iBack sofrerá a modificação mostrada na Figura 35. Desta forma iBack e iFront vão variar de 0 a 5, podendo em seguida voltar a 0, sendo o vetor preenchido de forma circular. Figura 35 ‐ Exemplo de Inserção na Fila Circular
31 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 5.3
Operações sobre Fila Estática Do ponto de vista de operações a fila possui restrições assim como a pilha. Neste caso as operações serão essencialmente as mesmas. Não é possível em uma fila, realizar operações como as previstas na lista que permitem a inserção e remoção de qualquer objeto. 5.4
Fila Estática ‐ Implementação em C++ A implementação da fila estática pode ser dividada em dois arquivos. Um deles, chamado “Queue.h” conterá a definição da classe. Já o arquivo “Queue.cpp” possuirá a implementação de todas as operações possíveis para fila. # ifndef QUEUE_H
# define QUEUE_H
# include <iostream>
//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] ;
public:
//Construtor
Queue (void);
//MODIFICAÇÃO (INSERÇÃO E REMOÇÃO)
int void 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
int getSize(void) const;
int isEmpty(void) const;
int isFull(void) const;
};
# endif //QUEUE_CLASS
Figura 36 ‐ Definição de Atributos e Métodos da Fila (Queue.h)
32 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação # ifndef QUEUE_CLASS
# define QUEUE_CLASS
// inicializa as variáveis membro da fila iFront, iBack, iSize
template <class T> Queue<T>::Queue (void) {
iFront = 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] ;
}
// Recupera o objeto que se encontra no final da fila
template <class T> T Queue<T>::getBack(void) const {
return queueData[iBack] ;
}
//Recupera
o número de elementos na fila
template <class T> int Queue<T>::getSize(void) const {
return iSize;
} //Insere
um elemento na fila
template <class T> int Queue<T>::push (const T& item) {
//Finaliza se a fila estiver cheia retorna 1, indicando erro
if (isFull()){
return 1;
}
// 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;
}
Figura 37 ‐ Operações de Consulta, Alteração e Inserção (Queue.cpp) Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação 33 // 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()){
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
//uma
posição
iFront
= (iFront+1) % iMaxQueueSize;
//Retorna indicando sucesso
return 0;
} //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;
}
//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;
}
Figura 38 ‐ Operações de Remoção e Apoio (Queue.cpp)
34 Estrutura de Dados – Apostila ‐ Prof. Flávio de Oliveira Silva, M.Sc. ‐ Faculdade de Computação