universidade federal de uberlândia faculdade de...

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

2.1 Coleções Lineares .......................................................................................................................... 5

2.2 Coleções Não Lineares .................................................................................................................. 5

2.3 Coleções Lineares – Formas de Acesso ......................................................................................... 6

3. 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

4. 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

5. 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


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


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

Figura 1 ‐ Classificação das Estruturas de Dados


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:

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:

Lista (List)

Pilha (Stack)

Fila (Queue)

Figura 2 ‐ Acesso Direto

Figura 3 ‐ Acesso Sequencial


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


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


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).

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

Figura 6 ‐ Representação da Lista Estática

class Domain Objects

List

- size: int- l istData[MAXLISTSIZE]: T

Figura 7 ‐ Representação UML da Lista Estática


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.

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;

typedef double T;

struct List {

T listaData[MAXLISTSIZE];

int size;

};

Figura 8 ‐ Representação da Lista Estática em C


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:

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

Figura 9 ‐ Inserção com Movimentaçã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:

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.

Figura 10 ‐ Remoção do i‐ésimo objeto


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)


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.

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



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


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


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


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


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.

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.

Figura 17 ‐ Definição Pilha


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).

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.

Figura 18 ‐ Pilha Estática e Dinâmica

Figura 19‐ Representação da Pilha Estática


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)

typedef double T;

struct Stack {

T stackData[MAXSTACKSIZE];

int iTop;

};

Figura 21 ‐ Representação da Pilha Estática em C


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)

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)

Figura 23 ‐ Remoção da Pilha (pop)


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.

Figura 24 ‐ Recuperação do Topo (peek)


# ifndef STACK_H

# define STACK_H


# 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


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


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


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


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

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)


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.

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 29 ‐ FIla Estática e Dinâmica

Figura 30 ‐ Representação Inicial da Fila Estática


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.

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 31 ‐ Deficiência da Representação Inicial da Fila

Figura 32 ‐ Representação Melhorada da Fila


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.

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.

Figura 33 ‐ Efeito Colateral da Representação Melhorada


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

Figura 35 ‐ Exemplo de Inserção na Fila Circular


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


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


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


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


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

universidade federal de uberlândia faculdade de...

Documents