Universidade Federal de Uberlândia Faculdade de Computação

Transcrição

1 Universidade Federal de Uberlândia Faculdade de Computação Prof. Flávio de Oliveira Silva, M.Sc. Março de 2010

2 2

3 Sumário Lista de Figuras Introdução Coleção de Dados Coleções Lineares Coleções Não Lineares Coleções Lineares Formas de Acesso Lista Lista Estática Lista Dinâmica Representação da Lista Representação da Lista Estática Operações sobre uma Lista Lista Estática Implementação em C Pilha Pilha Estática e Dinâmica Representação da Pilha Estática Operações sobre a Pilha Pilha Estática Implementação em C Fila Fila Estática e Dinâmica Representação da Fila Estática Operações sobre Fila Estática Fila Estática Implementação em C

4 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 Figura 9 Inserção com Movimentação Figura 10 Remoção do i ésimo objeto Figura 11 Atributos Classe List (List.h) Figura 12 Métodos Classe List (List.h) Figura 13 Operações de Consulta e Alteração (List.cpp) Figura 14 Operações de Inserção e Remoção (List.cpp) Figura 15 Operações de Remoção e Apoio (List.cpp) Figura 16 Operações de Apoio (List.cpp) Figura 17 Definição Pilha Figura 18 Pilha Estática e Dinâmica Figura 19 Representação da Pilha Estática Figura 20 Representação da Lista Estática em C Figura 21 Representação da Pilha Estática em C Figura 22 Inserção na pilha (push) Figura 23 Remoção da Pilha (pop) Figura 24 Recuperação do Topo (peek) Figura 25 Definição de Atributos e Métodos da Pilha (stack.h) Figura 26 Operações de Consulta e Inserção (Stack.cpp) Figura 27 Operações de Apoio e Remoção (Stack.cpp) Figura 28 Operações de Apoio (Stack.cpp) Figura 29 FIla Estática e Dinâmica Figura 30 Representação Inicial da Fila Estática Figura 31 Deficiência da Representação Inicial da Fila Figura 32 Representação Melhorada da Fila Figura 33 Efeito Colateral da Representação Melhorada Figura 34 Representação da Fila de forma Circular Figura 35 Exemplo de Inserção na Fila Circular Figura 36 Definição de Atributos e Métodos da Fila (Queue.h) Figura 37 Operações de Consulta, Alteração e Inserção (Queue.cpp) Figura 38 Operações de Remoção e Apoio (Queue.cpp)

5 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 Figura 1 Classificação das Estruturas de Dados 2.1 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

6 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 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: Vetor (Array) Arquivo (File) Figura 2 Acesso Direto 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: Lista (List) Pilha (Stack) Fila (Queue) Figura 3 Acesso Sequencial 6

7 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

8 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. a 1, a 2, a 3,..., a n 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 8

9 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 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 Objects List - size: int - listdata[maxlistsize]: T Figura 7 Representação UML da Lista Estática 9

10 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 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

11 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; 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

12 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(); 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

13 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

14 //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

15 # 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

16 // 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) 16

17 // 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... << endl; return 1; //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) 17

18 //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) 18

19 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. a 1, a 2, a 3,..., 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 a 1 e o último o objeto a n, porém somente é possível a remoção do objeto a n. Para remover o objeto a 1 é 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. 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

20 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 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]; 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

21 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 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

22 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() 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

23 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; 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

24 # 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

25 # 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

26 // 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

27 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. a 1, a 2, a 3,..., a n 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 a 1 e o último o objeto a n, porém somente é possível a remoção do objeto a 1. Para remover o objeto a n é 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 a n O objeto a 1 é conhecido como o início da fila e o objeto a n é conhecido como o final da fila 27

28 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. 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 Representação Inicial Neste caso será utilizado para representar a fila: Figura 29 FIla Estática e Dinâmica 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

29 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 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

30 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 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

31 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: Figura 34 Representação da Fila de forma Circular 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

32 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

33 # 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) 33

34 // 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