estrutura de dadosflavio/ed1/files/ed1.pdf · estrutura de dados flávio de oliveira silva 4...

Estrutura de Dados Flávio de Oliveira Silva 1

ESTRUTURA DE DADOS

FLÁVIO DE OLIVEIRA [email protected]

[email protected]


OBJETIVOS DA DISCIPLINA� Apresentar as estruturas de dados pilha, fila, listas e

grafos.� Desenvolver as técnicas para sua representação e

os métodos de operação sobre as mesmas� Possibilitar a escolha de estruturas adequadas à

solução de problemas de representação da informação


EMENTA1. Revisão: Programação orientada à

objetos utilizando C+ +2. Filas3. Listas4. Grafos


BIBLIOGRAFIAAMMERAAL, L. Programs and Data Structres in C. Essex:

John Wiley & Sons, 1989.AHO, A. V. et alli. Data Structure and AlgorithmsTENENBAUM, A. M. et alli. Estruturas de Dados Usando C.

Rio de Janeiro: Makron Books, 1995SZWARCFITER, J. L. Grafos e Algorítmos Computacionais

Rio de Janeiro: Ed. Campus, 1984ESAKOV, J. Data Structres: An Advanced Approach Using

C. New Jersey: Prentice Hall, 1986


AVALIAÇÃO� Provas – Teóricas

� Primeira Prova – C+ + - 25 Pontos� Segunda Prova – 25 Pontos� Terceira Prova – 25 Pontos

� Trabalho – Projeto Conclusão de Curso – 25 Pontos� Executado em Etapas� Executado em Grupo; � Apresentação e Avaliação Individual

OBSERVAÇÕES� Material Apoio

� Pasta 122 – Xerox ao lado Bloco B

� Atendimento� Quarta-Feira 16:00 – 16:50 – Sala 1B54� Sexta-Feira 15:00 – 16:00 – Sala 1B54

� Aulas Práticas no laboratório


Estrutura de Dados� 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.

� Permite uma maior compreensão lógica de como resolver problemas

� As estruturas de dados representam maneiras de se organizar os dados (objetos) manipulados por um programa.

� Um programa faz uso de diferentes estruturas de dados, conforme sua necessidade

� As estruturas de dados serão estudas como objetos


COLEÇÃO DE DADOS� Um conjunto de dados(objetos),

organizados(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� LINEARES – Neste tipo os objetos são ordenados

pela sua posição, ou seja, existe o primeiro objeto, segundo, terceiro, etc. Ex.: Vetor

� NÃO-LINEARES – Neste tipo não existe uma ordem em seus objetos. Ex.: Árvore


COLEÇÕES LINEARES� Considerando a forma de acesso aos objetos as

coleções lineares podem ser divididas em três tipos:� ACESSO DIRETO� ACESSO SEQÜENCIAL� ACESSO INDEXADO

� ACESSO DIRETO – Neste tipo de coleção linear o acesso aos objetos pode ser feito em qualquer ordem, ou seja, é possível obter o terceiro objeto diretamente sem a necessidade de obter o primeiro e em seguida do segundo. Ex.: Vetor; Música em um CD

A0 A1 A2 … Ai … An-1

i


COLEÇÕES LINEARES� ACESSO SEQÜENCIAL – Neste tipo de coleção linear o

acesso aos objetos pode ser feito apenas em uma ordem seqüencial, ou seja, para obter o terceiro objeto e necessário primeiramente obter o primeiro e em seguida do segundo. Ex.: Retirar um caminhão estacionado em uma garagem;Obter trechos de uma fita Vídeo

� ACESSO INDEXADO – Neste tipo de coleção linear o acesso aos objetos é feito a partir de uma chave. Neste tipo de estrutura a chave pode estar armazenada juntamente com o objeto. Ex.: Dicionário


COLEÇÃO DE DADOSColeções

Lineares Não-Lineares

AcessoSequencial

AcessoDireto

AcessoIndexado

Vetor

Arquivo

PilhaListaFila

Dicionário

Tabela Hash

Hierarquicas Agrupadas

Árvore

Heap

ConjuntoGrafo


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

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

D��D��D��«��DQ Q�t �� Uma lista pode ter 0 ou mais objetos� O número Q�é o 7$0$1+2 da lista� Uma /,67$�9$=,$ não possui objetos.� Um lista é dita +202*Ç1($ quando todos objetos são

do mesmo tipo.


� Considerando que a lista é uma coleção de objetos onde existe o primeiro, segundo, etc. Como podemos representa-lá?

� LISTA ESTÁTICA – Neste caso os objetos de uma lista estarão contidos em um Vetor

� LISTA DINÂMICA – Neste caso os objetos da lista são alocados de forma dinâmica e um objeto qualquer deve conhecer a posição do seu próximo objeto.

LISTA

A1 A2 A3 … Ai … An

A1 A2 A3 Ai An... ...


� LISTA ESTÁTICA – Utilizada para representar situações onde o número de objetos é IL[R. Ex: Uma lista contendo disjuntores em um painel(o número máximo é fixo); Lista de equipamentos estocados em uma prateleira (o número de prateleiras é fixo). Lista de cabines telefônicas em uso (o número de cabines é fixo); Lista de passagens vendidas (o número de poltronas disponíveis é fixo); …

� LISTA DINÂMICA – Utilizada para representar situações onde o número de objetos irá YDULDU a medida que a lista é utilizada, sendo que não é possível prever qual será o número máximo de objetos. Ex: Projeto de circuitos de um painel (No projeto cada painel poderá ter um número qualquer de circuitos); Lista de equipamentos adquiridos; Lista de telefones instalados em uma localidade; Lista de reservas feitas para um determinado vôo; …

LISTA


� Para criar uma lista estática a partir de um vetor necessitamos basicamente das seguintes informações:� Um vetor que irá conter os objetos da lista (OLVW'DWD).� Este vetor irá conter um número máximo de objetos

(L0D[/LVW6L]H )� O vetor irá utilizar um tipo genérico de dados (7)� Um número inteiro que irá indicar o número de objetos

existentes nesta lista (L6L]H).� Inicialmente o número de objetos é igual a zero.� O número de objetos (L6L]H) deverá ser sempre menor

ou igual que o tamanho do vetor (L0D[/LVW6L]H)

LISTA ESTÁTICA - REPRESENTAÇÃO

5 3 22 1

int iSize;

T listDataiMaxListSize0


� PONTOS FORTES� Acesso direto indexado a qualquer objeto da lista � Tempo constante para acessar o objeto i (depende somente do

índice.

� PONTOS FRACOS� Movimentação quando eliminado/ inserido objeto � Tamanho máximo fixo, sendo necessário um conhecimento inicial

deste número

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

objetos.

LISTA ESTÁTICA


OPERAÇÕES SOBRE UMA LISTA� Qualquer objeto da lista pode ser recuperado,

e/ou modificado� É possível a inserção de novos objetos na lista� É possível a remoção de objetos da lista� Na lista estática algumas operações de inserção e

remoção exigem um grande esforço pois necessitam da movimentação de todos os outros objetos existentes na lista.


OPERAÇÕES SOBRE UMA LISTASerão definidas as seguintes operações para uma lista:� RECUPERAÇÃO e MODIFICAÇÃO DA INFORMAÇÃO

� JHW6L]H ± 5HWRUQD�R�Q~PHUR�GH�REMHWRVLQW�JHW6L]H�YRLG��FRQVW�� getFirst – Retorna o primeiro objeto(Objeto da classe T)7�JHW)LUVW��FRQVW�� getLast – Retorna o último objeto7�JHW/DVW��FRQVW�� JHW'DWD ± 5HWRUQD�XP�REMHWR�TXDOTXHU7�JHW'DWD�LQW��FRQVW�� VHW'DWD – Altera um objeto em uma determinada

posição - YRLG�VHW'DWD�LQW��7�� ILQG ± (QFRQWUD�D�SULPHLUD�RFRUUrQFLD�GH�XP�GHWHUPLQDGR�REMHWR�� ERRO�ILQG�7��FRQVW�


OPERAÇÕES SOBRE UMA LISTA� MÉTODOS DE APOIO

� LV(PSW\ ± 5HWRUQD�XP�ERROHDQR LQGLFDQGR�VH�D�OLVWD�HVWi�RX�QmR�YD]LDERRO�LV(PSW\�YRLG��FRQVW�� print – Imprime o conteúdo da listaYRLG�SULQW��FRQVW�

� INSERÇÃO DE NOVOS OBJETOSPara realizar a inserção, em certos casos, é necessária a movimetação de todos os objetos existentes no vetor.

... ...

0 1 i+1i... i+2 ... n-1 n

... ...

0 1 i+1i... i+2 ... n-1 n,QVHUomR GR�L�pVLPR�REMHWR

5 3 22 1O�LQVHUW)LUWVW��

iSize = 4

7 5 3 22 1Lista após inserção

iSize = 5


OPERAÇÕES SOBRE UMA LISTA� INSERÇÃO DE NOVOS OBJETOS

� LQVHUW ± ,QVHUH�XP�REMHWR�QR�ILQDO�GD�OLVWDYRLG�LQVHUW�FRQVW 7�� insertFirst – Insere um objeto no início da listaYRLG�LQVHUW)LUVW�FRQVW 7�� insertLast – Insere um objeto no final da listaYRLG�LQVHUW/DVW�FRQVW 7�� insertAt – Insere um objeto em uma posição qualquerYRLG�LQVHUW$W�LQW��FRQVW 7�� insertAfter – Insere um objeto após uma determinada

posiçãoYRLG�LQVHUW$IWHU�LQW��FRQVW 7�� insertBefore – Insere um objeto antes de uma

determinada posiçãoYRLG�LQVHUW%HIRUH�LQW��FRQVW 7��


OPERAÇÕES SOBRE UMA LISTA� REMOÇÃO DE OBJETOS

Da mesma forma que a inserção, a remoção em uma lista estática necessita, em certos, casos da movimentação de todos os objetos existentes na lista.Dependendo do tamanho da lista, esta operação exige um esforço computacional extra.

... ...

0 1 i+1i... i+2 ... n-1 n

... ...

0 1 i+1i... i+2 ... n-1 n

5HPRomR�GR�L�pVLPR�REMHWR

7 5 3 22 1O�UHPRYH��

iSize = 4

7 5 22 1Lista após remoção

iSize = 5


OPERAÇÕES SOBRE UMA LISTA� REMOÇÃO DE OBJETOS

� UHPRYH�± 5HPRYH�D�SULPHLUD�RFRUUrQFLD�GH�XP�REMHWRYRLG UHPRYH�FRQVW 7�� UHPRYH)LUVW ± 5HPRYH�R�SULPHLUR�REMHWR�GD�OLVWD7�UHPRYH)LUVW�YRLG�� removeLast – Remove o último objeto da lista7�UHPRYH/DVW�YRLG�� removeAt – Remove um objeto em uma posição indicada7�UHPRYH$W�LQW�� UHPRYH$OO ± 5HPRYH�WRGRV�RV�REMHWRVYRLG�UHPRYH$OO�YRLG�


DEFINIÇÃO DA LISTA – List.h# include < iostream># define iMaxListSize 32template < class T> class List {

private:/ /Vetor que irá conter os objetos da listaT listData[ iMaxListSize];/ /Número de objetos da listaint iSize;

public:/ / constructorList(void); / / Metodos Acessores/ /Recupera o número de objetos da listaint getSize(void) const;/ /Recupera a informação contida em uma determinada posiçãoT getData(int) const;


DEFINIÇÃO DA LISTA – List.h/ /Métodos Modificadores/ /Altera o conteudo da lista em uma determinada posiçãovoid 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 listaT removeFirst(void);/ /Remove todos os objetos da listavoid removeAll(void);/ /Outros métodos/ /Retorna um valor booleano indicando se a lista é o não vazia bool isEmpty(void) const;/ /Encontra a primeira ocorrência de um objeto da listabool find(T&) const ;/ / imprime o conteudo da listavoid print() const;

} ;


DEFINIÇÃO DA LISTA – List.cpp# include < iostream># include "List.h"using namespace std;template < class T> List< T> ::List(void){

/ /Tamanho inicial da lista é zeroiSize = 0;

}/ / retorna o número de objetos da listatemplate < class T>int List< T> ::getSize(void) const{

return iSize;}


DEFINIÇÃO DA LISTA – List.cpp/ /Retorna o objeto existente em uma determinada posição da lista/ /Caso a posição seja inválida, o programa será finalizado!template < class T> T List<T> ::getData(int pos) const {

/ / Termina o programa caso a posição seja inválidaif (pos < 0 | | pos > = iSize) {

cerr < < "Posição inválida!!!" < < endl;exit();

}return listData[pos] ;

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

if (pos < 0 | | pos > = iSize) {cerr < < "Posição inválida!!!" < < endl;exit(1);

}listData[pos] = data;

}


DEFINIÇÃO DA LISTA – List.cpp/ / Insere um objeto no final da listatemplate < class T> void List< T> ::insert(const T& item){

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

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

}/ / Insere um objeto no final da listalistData[ iSize] = item;/ / Incrementa o número de objetosiSize+ + ;

}


DEFINIÇÃO DA LISTA – List.cpp/ / Procura por um item na lista e remove a primeira ocorrênciatemplate < class T> void List< T> ::remove(const T& item) {

/ / Inicializa uma variável ii que será utilizada para percorrer a listaint ii(0);/ / Procura por um objetowhile (ii < iSize && !(item = = listData[ ii] ))

ii+ + ;/ /Caso ii seja igual ou maior que iSize, então não foi encontradoif (ii = = iSize)

return; / /Decrementa o tamanho da listaiSize--;/ / 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 iiwhile (ii < iSize){listData[ ii] = listData[ ii+ 1] ;ii+ + ;

} }


DEFINIÇÃO DA LISTA – List.cpp/ / Verifica se a lista está vaziatemplate < class T> bool List<T> ::isEmpty(void) const {

if (iSize = = 0)return true;

elsereturn false;

}

/ / Remove todos os objetos da listatemplate < class T>void List< T> ::removeAll(void){

iSize = 0;}


DEFINIÇÃO DA LISTA – List.cpp/ / Remove o primeiro objeto da lista e retorna o valor removido/ /Caso a posição seja inválida, o programa será finalizado!template < class T> T List<T> ::removeFirst(void) {

T frontI tem;

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

cerr < < "Erro! Tentativa de remover um objeto de uma lista vazia..."< < endl;exit(1);

}/ /Recupera o primeiro objetofrontI tem = listData[0] ; / /Remove o primeiro objetoremove(frontI tem); / / retorna o valor removido return frontI tem;

}


DEFINIÇÃO DA LISTA – List.cpp/ /Este método irá percorrer a lista a fim de encontrar o objeto item//Caso o mesmo não seja encontrado retorna falsetemplate < class T> bool List<T> ::find(T& item) const {

int ii(0);/ /Caso a lista seja vazia retorna falseif (isEmpty())

return false;/ /Procura pelo objeto na listawhile (ii < iSize && !(item = = listData[ ii] ))

ii+ + ;

/ /Caso ii seja igual ao tamanho da lista, indica que o item//nao foi encontradoif (ii = = iSize)

return false;

return true;}


DEFINIÇÃO DA LISTA – List.cpptemplate < class T> void List< T> ::print()const {

int ii(0);

/ /Caso a lista seja vazia retornaif (isEmpty()){

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

}

cout < < "Imprimindo o conteudo da lista..." < < endl;

while (ii < iSize){cout < < "objeto: " << ii < < " - " < < listData[ ii] < < endl;ii+ + ;

}}


PROJETO DE CONCLUSÃO DE CURSO� Valor: 25 pontos� Apresentação: Entrevista de avaliação� O projeto será entregue em etapas durante o curso. Dessa

forma partes bem definidas serão entregues em diferentes datas.

� O trabalho será feito em grupo e o mesmo deverá possuir no máximo 2 pessoas.

� Cada participante deverá ficar responsável por implementar classes específicas, porém será necessário o entendimento da solução como um todo.

� Os projeto deverá ser executado utilizando o ambiente de programação DevC+ +

� O projeto deverá ser entregue através de e-mail([email protected])


PROJETO DE CONCLUSÃO DE CURSO� CRITÉRIOS DE AVALIAÇÃO

� RESPEITO AO CRONOGRAMA - Neste item, será verificado se o grupo entregou todas as etapas nas datas solicitadas.

� FINALIZAÇÃO DA PROPOSTA – Será feita uma proposta de trabalho contendo os requisitos necessários ao software. Ao final será feita uma verificação se todos estes requisitos foram implementados e além disso serão feitos testes para verificar o funcionamento do software como um todo.


PROJETO DE CONCLUSÃO DE CURSO� CRITÉRIOS DE AVALIAÇÃO (continuação)

� ENTREVISTA INDIVIDUAL - Cada participante deverá apresentar e explicar os conceitos utilizados na parte que ficou sob sua responsabilidade. Os participantes serão argüidos e será verificado o conhecimento adquirido; o entendimento da solução; o conhecimento da linguagem e seus recursos. Este item será analisado e pontuado individualmente.


PROJETO DE CONCLUSÃO DE CURSO� 3ULPHLUD�(WDSD:Consiste na finalização da implementação da

classe List que consiste de uma lista, implementada de forma estática e que utiliza o recurso de modelos(templates) de C+ +

� Data de Entrega: 25/06/2003� Os seguintes métodos deverão ser implementados

� Retorna o primeiro objeto - T getFirst() const;� Retorna o último objeto - T getLast() const;� Insere um objeto no inicio da lista - void insertFirst(const T&);� Insere um objeto no final da lista - void insertLast(const T&);� Insere um objeto em uma posição qualquer - void insertAt(int, const

T&);� Insere um objeto após uma posição especificada - void insertAfter(int,

const T&)� Insere um objeto antes de uma posição especificada - void

insertBefore(int, const T&)� Remove o ultimo objeto da lista - T removeLast(void);� Remove um objeto em uma posição especificada - T removeAt(int);


PROJETO DE CONCLUSÃO DE CURSO� 3ULPHLUD�(WDSD(continuação)� A função PDLQ�� deverá ser modificada a fim de conter um

exemplo de utilização de cada método, sendo necessário colocar comandos de entrada e/ou saída, conforme cada caso, para demonstrar a utilização e o resultado fornecido por cada método.


� Uma pilha é uma coleção de objetos que possuem uma relação de ordem entre si, ou seja, existe o primeiro; segundo; etc.

� Porém na pilha os objetos obedecem ao princípio "Último a entrar/Primeiro a sair" - LIFO (Last-in/First Out)

D��D��D��«��DQ Q�t �

� Na pilha acima, o primeiro objeto a entrar foi o objeto D�e o último o objeto DQ, porém somente é possível a remoção do objeto DQ.

� Desta forma para remover o objeto D� é necessário antes remover todos os outros objetos e finalmente será possível a remoção de D�

� O objeto DQ é conhecido como o 7232 da pilha

PILHA

A1 A2 A3 … Ai … An

A1

A2

A3

…Ai

…An 72327232


� Uma pilha pode ter 0 ou mais objetos� Uma PILHA VAZIA não possui objetos.� Uma pilha, pode ser implementada como uma lista onde

todas as inserções e remoções são feitas somente em uma de suas extremidades.

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

PILHA


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

� PILHA ESTÁTICA – Neste caso os objetos da pilha estarão contidos em um Vetor

� PILHA DINÂMICA – Neste caso os objetos da pilha são alocados de forma dinâmica e um objeto qualquer deve conhecer a posição do seu próximo objeto.

PILHA

A1 A2 A3 … Ai … An

A3 A2An Ai A1... ...


� Para criar uma pilha estática a partir de um vetor necessitamos basicamente das seguintes informações:� Um vetor que irá conter os objetos da pilha (VWDFN'DWD).� Este vetor irá conter um número máximo de objetos

(L0D[6WDFN6L]H)� O vetor irá utilizar um tipo genérico de dados (7)� Um número inteiro que irá indicar o índice do TOPO da

pilha (L7RS).� Inicialmente o TOPO da pilha é igual a zero.� O TOP número de objetos (L7RS) deverá ser sempre

menor ou igual que o tamano do vetor (L0D[6WDFN6L]H)

PILHA ESTÁTICA - REPRESENTAÇÃO

5 3 22 1

int iTop;

T stackDataiMaxStackSize0


OPERAÇÕES CLÁSSICAS SOBRE UMA PILHA� Somente o objeto que está no TOPO da pilha

pode ser recuperado (peek)� É possível a inserção (push) de novos objetos no

TOPO da pilha� É possível a remoção (pop) somente do objeto

que se encontra no TOPO da pilha


OPERAÇÕES SOBRE UMA PILHA� INSERÇÃO DE NOVOS OBJETOS

� SXVK ± ,QVHUH um objeto no WRSR da pilha, caso a mesma não esteja cheia

YRLG�SXVK�FRQVW�7�LWHP��

41 7232�

�L7RS� ��

iMaxStackSize

0 413 7232�

�L7RS� ��

S�SXVK��

4132 7232�

�L7RS� ��S�SXVK��

0 0


OPERAÇÕES SOBRE UMA PILHA� REMOÇÃO DE OBJETOS

� SRS�± 5HPRYH o objeto que se encontra no WRSR da pilha, retornando o objeto removido

7�SRS�YRLG��

� UHPRYH$OO ± 5HPRYH todos os objetos da pilhaYRLG UHPRYH$OO�YRLG��

4132 7232�

�L7RS� ��

iMaxStackSize

0 413 7232�

�L7RS� ��

S�SRS��

41 7232�

�L7RS� ��

S�SRS��

0 0


OPERAÇÕES SOBRE UMA PILHA� RECUPERAÇÃO DA INFORMAÇÃO

� SHHN± 5HFXSHUD o objeto que se encontra no WRSR da pilha, sem no entando retirá-lo da pilha - 7�SHHN�YRLG��

� JHW6L]H ± 5HWRUQD�R�Q~PHUR�GH�REMHWRV QD�SLOKDLQW�JHW6L]H�YRLG��FRQVW�� ILQG ± (QFRQWUD�D�SULPHLUD�RFRUUrQFLD�GH�XP�GHWHUPLQDGR�REMHWRERRO�ILQG�7��FRQVW�

4132 7232�

�L7RS� ��

iMaxStackSize

0 4132

S�SHHN��

4132

0 0

S�SHHN��

7232��L7RS� ��

7232��L7RS� ��


OPERAÇÕES SOBRE UMA PILHA� MÉTODOS DE APOIO

� LV(PSW\ ± 5HWRUQD�XP�ERROHDQR LQGLFDQGR�VH�D�SLOKD HVWi�RX�QmR�YD]LDERRO�LV(PSW\�YRLG��FRQVW�� LV)XOO ± 5HWRUQD�XP�ERROHDQR LQGLFDQGR�VH�D�SLOKDHVWi�RX�QmR�FKHLDERRO�LV)XOO�YRLG��FRQVW�� SULQW ± ,PSULPH�R�FRQWH~GR�GD�SLOKDYRLG�SULQW��FRQVW�


DEFINIÇÃO DA PILHA – Pilha.h# ifndef STACK_CLASS# define STACK_CLASS# include < iostream># define iMaxStackSize 32template < class T>class Stack{

private:/ /Vetor que irá conter os elementos da pilhaT stackData[ iMaxStackSize] ;/ / Inteiro que indica o índice do topo da pilhaint iTop;


DEFINIÇÃO DA PILHA – Pilha.hpublic:

/ / construtorStack (void); ��2SHUDo}HV�GH��PRGLILFDomR�GD�SLOKD

/ /Armazena um item na pilha no topo da pilhavoid push (const T&);/ /Remove o topo da pilhaT pop (void);/ /Remove todos os objetos da pilhavoid removeAll(void); / / Obtém objeto que se encontra no topo da pilha sem modifica-loT peek (void) const; ��0pWRGRV�GH�DSRLRbool isEmpty(void) const;bool isFull(void) const;void print()const;

} ;


DEFINIÇÃO DA PILHA – Pilha.h/ / Construtor do objeto pilhatemplate < class T> Stack<T> ::Stack (void){ iTop = -1 }

/ /Armazena um item na pilha no topo da pilha/ /Caso a pilha esteja cheia o programa será finalizado!/ /Esta não é a melhor opção, um forma melhor seria utilizar o/ /conceito de EXCEÇÕEStemplate < class T> void Stack< T> ::push (const T& item){

/ / Verifica se a pilha está cheia, finalizif (isFull()) {

cerr < < "A pilha está cheia!" < < endl;exit(1);

}/ / incrementa o topo da pilha iTop+ + ;/ /coloca o elemento no topo da pilhastackData[ iTop] = item;

}


DEFINIÇÃO DA PILHA – Pilha.h/ /Remove o topo da pilha e o elemento que se encontra nesta posição/ /Caso a pilha esteja vazia o programa será finalizado!/ /Esta não é a melhor opção, um forma melhor seria utilizar o/ /conceito de EXCEÇÕEStemplate < class T> T Stack< T> ::pop (void) {

T temp;/ / Verifica se a pilha está vazia. Caso esteja o programa será finalizadoif (isEmpty()) {

cerr < < "A pilha está vazia!" < < endl;exit(1);

}/ / obtem o elemento que está no topotemp = stackData[ iTop] ;/ /decrementa o topo da pilha

iTop--;return temp;

}


DEFINIÇÃO DA PILHA – Pilha.h/ / Obtem o objeto que se encontra no topo da pilha sem modifica-latemplate < class T> T Stack< T> ::peek (void) const {

/ / Verifica se a pilha está vazia. Caso esteja o programa será finalizadoif (isEmpty()) {

cerr < < "A pilha está vazia!" < < endl;}return stackData[ iTop] ;

}/ /Verifica se a pilha está vaziatemplate < class T>bool Stack<T> ::isEmpty(void) const {

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

}


DEFINIÇÃO DA PILHA – Pilha.h/ /Verifica se a pilha está cheiatemplate < class T> bool Stack< T> ::isFull(void) const {

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

}/ / Limpa a pilhatemplate < class T> void Stack< T> ::removeAll(void) {

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

}


DEFINIÇÃO DA PILHA – Pilha.htemplate < class T> void Stack< T> ::print()const {

/ /Começa a partir do topoint ii(iTop);/ /Caso a pilha seja vazia retornaif (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


� Uma pilha é uma coleção de objetos que possuem uma relação de ordem entre si, ou seja, existe o primeiro; segundo; etc.

� Porém na pilha os objetos obedecem ao princípio “Primeiro a entrar/Primeiro a sair" - FIFO (First-in/FirstOut)

D��D��D��«��DQ Q�t �� Na filha acima, o primeiro objeto a entrar foi o objeto D�

e o último o objeto DQ, porém somente é possível a remoção do objeto D�.

� Da mesma forma, caso um novo objeto seja inserido nafila a sua posição será Q��, visto que o último objetoque foi colocado na fila foi o objeto QD

� O objeto DQ é conhecido como o ),1$/ da fila� O objeto D� é conhecido como o ,1Ë&,2 da fila

FILA


� Uma fila pode ter 0 ou mais objetos� Uma FILA VAZIA não possui objetos.� Uma fila, pode ser implementada como uma lista onde

todas as inserções são feitas em uma extremidade e asremoções são feitas somente na outra extremidade da fila

� Caso o ,1Ë&,2 da fila seja o primeiro objeto da lista o ),1$/ da fila será o último objeto da lista.

FILA


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

� FILA ESTÁTICA – Neste caso os objetos da fila estarão contidos em um Vetor

� FILA DINÂMICA – Neste caso os objetos da fila são alocados de forma dinâmica e um objeto qualquer deve conhecer a posição do seu próximo objeto.

FILA

A1 A2 A3 … Ai … An

A3 A2An Ai A1... ...


� Informações necessárias para representar uma fila estática a partir de um vetor:� Um vetor que irá conter os objetos da pilha (TXHXH'DWD).� Este vetor irá conter um número máximo de objetos

(L0D[4XHXH6L]H)� O vetor irá utilizar um tipo genérico de dados (7)� A posição 0 irá indicar o ,1Ë&,2 da fila.� Um número inteiro indicando a próxima posição disponível

no vetor após ),1$/ da fila (L%DFN).� Inicialmente o TOPO da pilha é igual a zero.� O TOP número de objetos (L7RS) deverá ser sempre menor

ou igual que o tamanho do vetor (L0D[4XHXH6L]H)

FILA ESTÁTICA – REPRESENTAÇÃO INICIAL

5 3 22 1T stackDataiMaxQueueSize0

int iBack;


� Da maneira como a fila está modelada a mesma apresenta deficiências. Por exemplo, supondo que a fila possui um tamanho máximo de 1000 objetos e que esta cheia:

� Ao remover o objeto que está no TOPO da fila será necessário mover todos os objetos

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

REPRESENTAÇÃO INICIAL – PROBLEMAS!

5 3 22 1 … 9T stackDataiMaxQueueSize = 10000

int iBack;

5 3 22 1 … 9iMaxQueueSize = 10000

int iBack;

3 22 1 … 9

int iBack;


� A fim de melhorar a representação da fila, será acrescentado um novo atributo no objeto.

� Neste caso será acrescentado um número inteiro (L)URQW) que irá indicar o ,1Ë&,2 da fila.

� Quando o objeto que está no início da fila for removido este valor será atualizado, desta forma não será necessário movimentar os objetos

� Porém neste caso, como fazer para indicar que uma nova posição está disponível na fila?

FILA – REPRESENTAÇÃO MELHORADA

5 3 22 1 … 9T stackDataiMaxQueueSize = 10000

int iBack;int L)URQW;

3 22 1 … 9iMaxQueueSize = 10000

int iBack ????int L)URQW;


� A fim de resolver o problema anterior, será feita a seguinte modificação na fila:

� Neste caso a fila irá se comportar de maneira circular ou seja, quando um novo elemento for inserindo última posiçãodo vetor (iMaxQueueSize-1) o valor de iBack será igual a zero, ou seja a primeira posição do vetor:L)URQW ��L)URQW�� L0D[4XHXH6L]H�L%DFN ��L%DFN�� L0D[4XHXH6L]H�� 2SHUDGRU�PyGXOR��UHWRUQD�R�UHVWR�GD��GLYLVmR�LQWHLUD��([��

FILA – REPRESENTAÇÃO FINAL


� Por exemplo: sendo iMaxQueueSize = 6; iFront= 1; iBack= 5; temos a seguinte situação

� Ao inserir um novo elemento (8) teremos:

� Desta forma iBack e iFront vão variar de 0 a 5, podendo em seguida voltar a 0, neste caso o vetor é preenchido de forma circular.

FILA – REPRESENTAÇÃO FINAL

T stackData 3 22 1 2iMaxQueueSize = 60

int iBack = 5int iFront

T stackData 3 22 1 2 8iMaxQueueSize = 60

int iBack = 0

int iFront = 1


DEFINIÇÃO DA FILA – Pilha.h# ifndef QUEUE_CLASS# define QUEUE_CLASS# include < iostream>/ / Tamanho Máximo de Elementos na filaconst int iMaxQueueSize = 32;

template < class T>class Queue {

private:/ / queue array and its parametersint iFront, iBack, iSize;T queueData[ iMaxQueueSize] ;


DEFINIÇÃO DA FILA – Pilha.hpublic:/ / ConstrutorQueue (void); / / MODIFICAÇÃO (INSERÇÃO E REMOÇÃO)void push(const T& item);T pop(void);void removeAll(void);/ / RECUPERAÇÃO DA INFORMAÇÃOT getFront(void) const;T getBack(void) const;/ / MÉTODOS DE APOIOint getSize(void) const;int isEmpty(void) const;int isFull(void) const;

} ;


DEFINIÇÃO DA FILA – Pilha.h/ / inicializa as variáveis membro da fila iFront, iBack, iSizetemplate < class T> Queue< T> ::Queue (void) {iFront = 0;iBack = 0; iSize = 0;

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

return queueData[ iFront] ;}/ / Recupera o objeto que se encontra no final da filatemplate < class T> T Queue<T> ::getBack(void) const {

return queueData[ iBack] ;}


DEFINIÇÃO DA FILA – Pilha.h/ / Recupera o número de elementos na filatemplate < class T> int Queue<T> ::getSize(void) const {

return iSize;}/ / Insere um elemento na filatemplate < class T> void Queue<T> ::push (const T& item) {

/ / Finaliza se a fila estiver cheiaif (isFull()){

cerr < < "Fila cheia!" < < endl;exit(1);

}/ / Incrementa iSizeiSize+ + ;/ /Coloca o elemento na ultima posicaoqueueData[ iBack] = item;/ /Atualiza iBack, indicando a ultima posição disponíveliBack = (iBack+ 1) % iMaxQueueSize;

}


DEFINIÇÃO DA FILA – Pilha.h/ / Remove um elemento da fila e retorna seu valortemplate < class T> T Queue<T> ::pop(void) {

T temp;/ / Finaliza se a fila estiver vaziaif (isEmpty()){

cerr < < "Fila vazia!" < < endl;exit(1);

} / / Recupera o objeto que esta no inicio da fila e coloca em temptemp = queueData[ iFront] ;/ / Decrementa o tamanho da filaiSize--;/ /Atualiza o inteiro que representa o inicio da fila, avançando uma posiçãoiFront = (iFront+ 1) % iMaxQueueSize;/ /Retorna o inicio da filareturn temp;

}


DEFINIÇÃO DA FILA – Pilha.h/ / Verifica que a fila está vaziatemplate < 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á cheiatemplate < class T> int Queue<T> ::isFull(void) const {

/ / A fila está cheia quando iSize = = iMaxQueueSizereturn iSize = = iMaxQueueSize;

}/ / Remove todos os objetos da filatemplate < class T> void Queue<T> ::removeAll(void) {

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

}# endif / / QUEUE_CLASS


� LISTA DINÂMICA – Neste caso os objetos da lista são alocados de forma dinâmica e um objeto qualquer deve conhecer a posição do seu próximo objeto.

� Neste caso o tamanho da lista não tem um limite máximo e pode ser alterado a medida que novos elementos são alocados.

LISTA DINÂMICA

A1 A2 A3 Ai An... ...


� LISTA DINÂMICA – Utilizada para representar situações onde o número de objetos irá YDULDU a medida que a lista é utilizada, sendo que não é possível prever qual será o número máximo de objetos. Exemplos� Projeto de circuitos de um painel (No projeto cada painel

poderá ter um número qualquer de circuitos); � Lista de Cargas associadas a um Circuito Elétrico� Lista de equipamentos adquiridos; � Lista de telefones instalados em uma localidade; � Lista de reservas feitas para um determinado vôo;� …

LISTA DINÂMICA – APLICAÇÕES


� Para criar uma lista dinâmica precisamos estabelecer algumas idéias importantes:� O objeto contido na lista (GDWD). � Este objeto irá pertencer a uma classe genérica (7).� Cada objeto da lista será chamado de nó (1RGH)� A idéia básica é que o primeiro elemento, conheça o

endereço do segundo; o segundo nó, conheça o endereço do terceiro nó e assim por diante

� Logo um nó (1RGH) deve conhecer o endereço do seu próximo (QH[W) nó.

� Quando um nó não possui um próximo nó, ou seja, este nó for o último nó, seu próximo (QH[W) terá um valor nulo (18//)

LISTA DINÂMICA - REPRESENTAÇÃO

T data next


� O Atributo GDWD, contém o dado� O Atributo QH[W, contém o endereço do próximo nó. O

diagrama abaixo representa os dados na memória

� Uma outra forma para representar a lista é a seguinte:

LISTA DINÂMICA - REPRESENTAÇÃO

30 x140x100HQGHUHoR GDWD QH[W

50 x210x140

10 x390x210

90 x0x390 (NULL)

30 50 10 90

1RGH 1RGH (NULL)


# ifndef NODE_CLASS# define NODE_CLASStemplate < class T> class Node {

private:/ / next é o endereço do nó seguinteNode< T> * next;/ / Neste caso o nó irá conter um objeto da classe TT data;

public:/ / ConstrutorNode(const T&, Node<T> * );

LISTA DINÂMICA – Definição – Node.h


/ / RECUPERAÇÃO DA INFORMAÇÃOT getData() const;Node< T> * getNext(void) const;Node< T> * getLast(void);bool find(T&); / / MODIFICAÇÃO (INSERÇÃO E REMOÇÃO)/ / Insere um nó após o atualvoid insertAfter(Node< T>* );void insertLast(Node< T>* );/ /Remove um nó após o atualNode< T> * removeAfter(void);Node< T> * removeFirst(void);/ / MÉTODOS DE APOIOvoid print();/ /Libera a memóriavoid free();

} ;



/ / Construtor. Inicializa os dados e o próximo nó, cujo valor padrão/ /é NULL ou seja nulo, não ponta para nenhum endereçotemplate < class T>Node<T> ::Node(const T& item, Node<T>* pProx = NULL) {

data = item;next = pProx;

} / / Retorna o valor do próximo nótemplate < class T> Node<T>* Node<T> ::getLast(void) {

Node<T> * pTemp = this;Node<T> * pLast = pTemp;while (pTemp != NULL) {

pLast = pTemp;pTemp = pTemp->next;

}return pLast;

}



/ / Retorna um ponteiro para o último nó existentetemplate < class T>Node<T>* Node<T> ::getNext(void) const {

return next;}

/ / Retorna o valor do objeto contido no nótemplate < class T> T Node< T> ::getData(void) const {

return data;} / / Insere um nó após o nó atualtemplate < class T> void Node< T> ::insertAfter(Node< T> * p) {

/ / p aponta para o successor do nó corrente/ / e o nó corrente aponta para p.p-> next = next;next = p;

}



/ / Remove o nó seguinte ao nó atual e retorna seu endereçotemplate < class T> Node<T>* Node<T> ::removeAfter(void) {

/ / Salva o endereço do nó que será apagadoNode<T> * pTemp = next;/ / Se não existe o próximo nó então retornaif (next == NULL)

return NULL;

/ / O nó corrente irá apontar para o sucessor do próximo nónext = pTemp-> next;

/ / retorna o ponteiro para o nó que será removidoreturn pTemp;

}



/ / Encontra um itemtemplate < class T> bool Node<T> ::find(T& item) {

Node<T>* pCurrent = this;/ /Varre todos os nóswhile(pCurrent != NULL) {

/ /Verifica se o nó atual contém o dado a ser procuradoif (pCurrent-> data == item){

return true;}pCurrent = pCurrent-> next;

}

/ /Caso não tenha encontrado retorna false;return false;

}



/ / Imprime o conteudo dos nóstemplate < class T> void Node<T> ::print() {

int ii(0);cout < < "Imprimindo o conteudo da lista..." << endl;

Node<T> * pCurrent = this;

/ /Varre todos os nóswhile(pCurrent != NULL){cout < < "Elemento: " < < ii < < " - " < < pCurrent-> data < < endl;pCurrent = pCurrent->next;ii+ + ;

} }



/ / Insere um nó na última posiçãotemplate < class T> void Node<T> ::insertLast(Node<T>* pNew){

Node<T> * pCurrent = this;Node<T> * pLast;pLast = pCurrent-> getLast();pLast-> insertAfter(pNew);

}



/ /Libera a memória template < class T> void Node< T> ::free() {

cout < < "Liberando a memoria..." < < endl;Node< T> * pCurrent = this;Node< T> * pNext;pNext = pCurrent;/ /Limpa todos os nóswhile(pNext != NULL){

pNext = pCurrent-> next;delete(pCurrent);pCurrent = pNext;

} }# endif / / NODE_CLASS



# include < iostream># include <stdlib.h># include "Node.h"using namespace std;int main(int argc, char * argv[ ] ) {

/ /Cria o nó que irá representar a listaNode<string> * lis = NULL ;bool bContinue(true);

int iOpcao;string sNome;while (bContinue) {

/ /system("CLS");cout < < "\ tDigite a opcao desejada: " < < endl;cout < < "\ t[1] - Inserir elemento na lista" < < endl;cout < < "\ t[4] - Imprimir a lista" < < endl;cout < < "\ t[5] - Procurar um elemento na lista" << endl;cout < < "\ t[9] - Finalizar" < < endl;

LISTA DINÂMICA – Uso da Definição


cin > > iOpcao; switch (iOpcao) {

case 1:cout < < "Digite o nome a ser armazenado : " < < endl;cin > > sNome;/ /Caso seja o primeiro elemento a lista deverá ser alocada na / /memóriaif (lis = = NULL){

lis = new Node<string> (sNome); }else {

/ /Caso não seja o primero adiciona na ultima posicao da lista/ /Desta forma é possível preservar a variável lis, que contém//o inicio da listalis-> insertLast(new Node<string> (sNome));

}break;



case 4:lis-> print(); break;

case 5:cout < < "Digite o nome a ser procurado : " << endl;cin > > sNome;if (lis-> find(sNome))

cout < < "Nome encontrado!" << endl;else

cout < < "Nome nao encontrado!" < < endl; break;



case 9:bContinue = false;break;

default:cout < < "Opcao inválida! Digite Novamente..." < < endl;break;

}}/ /Libera a memorialis-> free();system("PAUSE");

return 0;}



# include < iostream># include <stdlib.h># include "Node.h"using namespace std;int main(int argc, char * argv[ ] ) {

/ /Cria o nó que irá representar a listaNode<string> * lis = NULL ;bool bContinue(true);

int iOpcao;string sNome;while (bContinue) {

/ /system("CLS");cout < < "\ tDigite a opcao desejada: " < < endl;cout < < "\ t[1] - Inserir elemento na lista" < < endl;cout < < "\ t[4] - Imprimir a lista" < < endl;cout < < "\ t[5] - Procurar um elemento na lista" << endl;cout < < "\ t[9] - Finalizar" < < endl;

cin > > iOpcao;


estrutura de dadosflavio/ed1/files/ed1.pdf · estrutura de dados flávio de oliveira silva 4...

Documents