Escolar Documentos
Profissional Documentos
Cultura Documentos
Introduo..............................................................................................................................................2
Metodologias.........................................................................................................................................3
Objectivos:............................................................................................................................................3
Objectivo geral..................................................................................................................................3
Objectivo especfico..........................................................................................................................3
Caso de Estudo......................................................................................................................................4
Sistema de Gesto de Clinicas...........................................................................................................4
Arrays....................................................................................................................................................5
Regras de Arrays............................................................................................................................5
Como declarar e inicializar um array.............................................................................................5
Percorrendo um Array....................................................................................................................6
Vectores.................................................................................................................................................8
3.Lista..................................................................................................................................................10
Tipos de Listas.....................................................................................................................................10
Lista simplesmente encadeada e no ordenada................................................................................10
Lista simplesmente encadeada e ordenada.......................................................................................10
Lista duplamente encadeada e no ordenada....................................................................................11
Lista duplamente encadeada e ordenada..........................................................................................11
Listas circulares...............................................................................................................................11
Listas Simples..................................................................................................................................12
Operaes sobre listas.........................................................................................................................12
Fila......................................................................................................................................................15
Representao de uma fila...................................................................................................................15
Operaes que formam a interface de uso de Fila................................................................................16
Pilha.....................................................................................................................................................21
rvore.................................................................................................................................................24
Tabela de Disperso.............................................................................................................................28
Concluso............................................................................................................................................32
Bibliografia..........................................................................................................................................33
Tabelas de autoavaliao.....................................................................................................................34
Anexos.................................................................................................................................................36
Introduo
Neste trabalho falaremos sobre o sistema de gesto de Stock. Este trabalho abrange-se nas
pesquisas que o grupo realizou sobre o controle e superviso do Docente Hamilton
Mutaquiha na cadeira de Estrutura de Dados e Algoritmos. O nosso caso de estudo
referente ao Sistema de Gesto de Stock uma vez que a escolha do tema foi livre, nos
escolhemos este tema porque temos vivido o cenrio de m armanezamento de produtos.
O presente trabalho ser compilado em duas partes (terica e prtica); onde a parte terica
corresponde a descrio das estruturas de dados que sero aqui usados e, a aparte prtica vai
corresponder a criao da aplicao usando separadamente as verses das estruturas.
A partir do nosso entender acerca do caso de estudo, iremos desenvolver uma aplicao capaz
de suprir as necessidades exigidas pelo problema, onde iremos solucionar sob diferentes de
abordagens , mantendo a essncia dos mesmos em termos de requisitos.
Metodologias
Aqui preconizamos a diviso parcial e equitativa do trabalho, onde priorizamos a procura de
conceitos/abordagens necessrios (as), anlise do que foi colectado, organizao e sntese
para a resoluo do problema.
Para a elaborao da parte terica tivemos como pilares algumas referncias bibliogrficas
que sem elas no nos seria possvel a descrio detalhada dos conceitos usados em todas as
fases de desenvolvimento desta aplicao ampliando os nossos horizontes.
Para a parte prtica desenvolvimento da aplicao propriamente dita foi feita em linguagem
java, com auxlio do editor eclipse.
Objectivos:
Objectivo geral
Desenvolver estruturas de dados com comportamentos de arrays, vetores, listas, filas, pilhas
tabelas de dispersao , rvores, complexidade algortmica e mtodos de pesquisa de dados.
Objectivo especfico
Desenvolver a teoria de dados com comportamentos de arrays, vetores, listas, filas, pilhas
tabelas de dispersao , rvores, complexidade algortmica e mtodos de pesquisa de dados e
aplicar os conhecimentos na construo de um programa que faz gesto de Stock.
Caso de Estudo
Sistema de Gesto de Stock
Reviso de conceitos:
Arrays
Arrays - So estruturas de dados capazes de representar uma coleo de variveis de um
mesmo tipo. Todo array uma varivel do tipo referencia e por isto, quando declarada como
uma varivel local dever sempre ser inicializada antes de ser utilizada.
Regras de Arrays
Um Array um objecto, e assim sendo, pode ser null (Palavra Reservada);
Um Array tem um tamanho fixo de entre zero e n posies;
O tamanho de um Array determinado no momento da sua criao e nunca mais
pode-se alterar;
O tamanho do Array sempre pode-se consultar atravs da varivel de instncia length;
Um Array com zero posies tambm chamado vazio, mas diferente de ser null;
A primeira posio num Array e indicado por 0, a segunda posio por 1, e assim por
diante;
O tipo de um Array, indica qual tipo de valor ele pode conter, e determinado no
momento da sua criao, no podendo ser alterado depois.
Como declarar e inicializar um array
Para utilizarmos um array, devemos criar uma varivel para guardar a referncia desse array.
A declarao dessa varivel semelhante declarao das variveis que vimos at agora.
Exemplo:
int numero []= new int [10];
Na linha 1 declaramos e inicializamos um array do tipo int com trs posies. Nas linhas 2, 3
e 4 inserimos no array os valores 124, 43 e 1023 nas posies 0, 1 e 2, respectivamente.
Outra forma de inserir valores no array e a seguinte:
int[] numeros = {2, 5, 7}: array de 3 posies, inicializadas para 2, 5, e 7.
String[] produtos = {"agua", "coca-cola"}: array de 2 posies: "agua", "coca-cola".
double[] agua = { 24.9, 90.3}: array de duas posies.
while (pos<produtos.length){
System.out.println(produtos[pos]);pos++;
}
Comentrio
No que diz respeito ao nosso estudo de caso, criamos um array do tipo produtos, criamos
quatro objectos do tipo produto e de seguida armazenamos os mesmos no array. Foram
implementados os mtodos de remocao e impresso de produtos contidos no array.
Vectores
A linguagem Java d suporte a vetores e matrizes (arrays) de diversas formas. Os vetores
constituem uma forma muito conveniente de organizar informaes em fileira. Por exemplo,
podemos formar um vetor com de marcas de cinco produtos de um dado armazem do
seguinte modo:
String marcas[] = { Fanta, Fanta-Uva, Sprite, Coca-cola, Sparleta };
Neste caso marcas[0] a marca do primeiro produto, isto , Fanta, marcas[1] a marca do
segundo, ou seja, Fanta-Uva, e assim por diante.
A utilizao de vectores e arrays em Java envolve trs etapas:
1. Declarar o vector ou matriz. Para isto, basta acrescentar um par de colchetes antes ou
depois do nome da varivel. Por exemplo:
Vector (int) x= new Vector (int)();
Comentrio
Em relao aos vectores fizemos o mesmo exerccio feito com os arrays, criamos cinco
objectos do tipo produto e com suporte do mtodo add da classe vector, addicionamos os
nossos produtos ao vector. Implementamos tambm alguns mtodos desta classe como:
add(ndex, obj), remove(ndex), remove(ndex, obj), ambos da classe vector.
Entretanto, nem sempre to fcil assim. Em geral, estaremos interessados em trabalhar com
vetores muito maiores, e cujos elementos sejam provenientes de outras fontes, que variam
com o tempo. Assim, seremos obrigados a seguir os passos acima.
Lista
Uma estrutura de dados do tipo lista representa um conjunto de dados organizados em ordem
linear.
Quando uma lista de dados representada por um arranjo, ou seja, feita a utilizao de
vetores na representao, tem-se o uso de endereoscontguos de memria no computador e a
ordem linear determinada pelos ndices do vetor. Tal representao denomina-se lista
esttica.
Quando a estrutura lista representada por elementos que, alm de conter os dados, possui
tambm um ponteiro para o prximo elemento, ou seja, elementos encadeados tem-se
representao denominadalista dinmica. Toda lista dinmica tem pelo menos um ponteiro
para o incio.
Quando um elemento de uma lista contm apenas um dado primitivo do tipo inteiro
denomina-se lista homognea, e quando o elemento de lista contm um dado composto
como nome, salrio de um funcionrio, chama-se lista heterognea.
Tipos de Listas
A estrutura de dados do tipo lista em diferente tipos e cada um pode ser implementado de
forma esttica e dinmica:
Listas circulares
Neste tipo de lista, temos um n muito parecido com o head de listas simples, mas neste caso,
ele aponta para o ltimo elemento da lista. Cada n guarda referncia para o prximo
elemento da lista e o ltimo aponta para o primeiro elemento da lista, criando um crculo.
10
Nestas listas, a insero fcil tanto no incio como no fim j que o primeiro elemento
referenciado pelo ltimo.
Representao de lista circular
Listas Simples
Neste tipo de lista, o n raiz, tambm conhecido por cabea da lista aponta para o primeiro
elemento da lista e por sua vez, este e cada um dos consecutivos, apontam para o seu
prximo, sendo que o ltimo elemento aponta para null.
Diferente de todos os outros ns, a cabea da lista tem apenas o campo que guarda referncia
para o primeiro elemento da lista, pelo que um n nulo.
Exemplo de uma lista simples:
Implementao de Listas
public boolean estaVazia();
public void inserirFim (Produto str);
public Produto removerFim();
public void inserirInicio(Produto str);
11
Comentrio
Implemtentamos as operacoes com listas no nosso estudo de caso, foi criada a classe
Nodo com os respectivos gets e sets que permitem o acesso e modificao no nodo.
Para garantir que todos metodos desejados fossem obrigatoriamente implementados
criamos uma interface de nome ListaProduto contendo apenas as assinaturas de
cada metodo, e a implementacao dos mesmos em outra classe de nome
ListaSimplesProduto.por fim a nossa classe com o main para testes onde fizemos uso
dos metodos: adicionar(), adicionarInicio(), AdicionarFim(), removerInicio(),
removerFim() e mais.
Fila
A fila uma lista linear em que todas as inseres de novos elementos so realizadas numa
extremidade da lista e todas as remoes de elementos so feitas na outra extremidade da
lista. Fila uma estrutura de dados simples, linear e de acesso sequencial, porm, diferente da
pilha. Esta, pode ser manipulada por 2 extremidades conhecidas como cauda (por onde
feita a insero de elementos na fila) e frente (por onde possvel remover-se os
elementos). A fila define uma prioridade para a remoo de elementos, por isso a fila
conhecida como uma estrutura FIFO FirstIn FirstOut.
12
Representao da Fila
A fila pode ser implementada de duas maneiras: a primeira usando a estrutura esttica
13
14
Comentrio
Em relao as Filas, a implementao em nosso caso de estudos foi baseada nas duas formas de
implementao: estticas e Dinmicas isto com arryas e listas. Para os dois casos foi criada uma
interface de nome Fila contendo as assinaturas dos mtodos que foram implementados em outra
classe de nome FilaArray para arrys e FilaLista para o caso das Listas. Por fim ambas tiveram as
classes de Testes.
Pilha
Uma Pilha uma coleco de dados, ou seja, uma estrutura de dados de comprimento
varivel que contm mltiplos elementos.
Uma pilha uma lista de informaes com operaes especiais de acesso. O acesso aos
elementos da pilha feito sempre pela mesma extremidade, isto , a extremidade escolhida
sempre usada para todas as operaes, seja de insero, eliminao ou pesquisa, e chamada
de TOPO. Esta regra tambm conhecida como LIFO (Last InFirst Out).
Para aceder um elemento na pilha necessrio que esteja no Top, caso contrario, todos
elementos que esto antes dele devem ser retirados.
Representao de uma pilha
16
Implementao de Pilhas
A pilha pode ser implementada por arrays ou listas. Abaixo est ilustrada a implementao de
uma pilha que pode guardar qualquer tipo de objectos.
Implementao de Pilha usando Array
public class PilhaArray implements Pilha {
Produto [] p;
17
int topo;
public PilhaArray(int Capacidade){
p=new Produto [Capacidade];
topo=0;
}
public boolean estaVazia(){
return topo==0;
}
public void push(Produto str){
p[topo]=str;
topo ++;
}
public Produto pop(){
topo--;
return p[topo];
}
public int obterTamanho(){
return topo;
}
public void imprimir(){
for(int i=topo-1; i>=0; i--){
System.out.println(p[i]);
}
}
public Produto topo() {
// TODO Auto-generated method stub
return null;
}
}
Comentrio
A implementao das pilhas no nosso caso de estudo obedeceu as particularidades que as pilhas nos trouxe, o
facto de existirem duas implementaes assim como as filas. Implementamos com arryas e listas. Seguimos o
procedimento usado nas filas a grande particularidade e diferena o facto da insero nas pilhas ser no topo
e a remoo a cauda enquanto que nas filas a insero na cauda e a remoo no topo.
18
Tabela de Disperso
Nas estruturas de dados vistas at agora, a busca por uma informao armazenada era feita
com base na comparao de chaves, ou seja, dada uma chave usava-se os mecanismos de
acesso para encontrar a mesma chave armazenada.
Veremos agora um novo mtodo de busca por chaves que tem como maior vantagem o fato
de que, na mdia dos casos, possvel encontrar a chave com apenas uma operao de
leitura.
A idia geral do mtodo gerar, a partir da chave procurada, o endereo da entrada de uma
tabela onde se encontra a informao associada chave. Este mtodo de transformao de
chaves conhecido na literatura com hashing (espalhamento) e a tabela chamada tabela de
disperso. A construo da tabela tambm feita com base em hashing, ou seja, a partir da
chave gerado um endereo de uma entrada que dever ser ocupada na tabela. Como pode
acontecer de que o mesmo endereo seja gerado a partir de mais de uma chave, so
necessrios mecanismos para tratar estas situaes chamadas de colises.
Definio
Uma tabela de dispero um vector de tamanho fixo, em que os elementos colados em
posio determinada por uma funo denominada funo de Dispero.
funo quando no se tem esse conhecimento aquela que calcula o resto da diviso de K por
M(mtodo da diviso): h(K) = K % M
Tratamento De Colises
Como j mencionamos muito comum o caso em que um mesmo endereo seja gerado para
mais de uma chave. Isto ocorre basicamente porque em geral o nmero N de chaves possveis
muito maior que o nmero de entradas disponveis M e tambm porque no se pode garantir
que as funes hashing em geral possuem um bom potencial de espalhamento.
As tcnicas de tratamento de coliso so basicamente de dois tipos: encadeamento e
endereamento aberto.
Encadeamento
Neste tipo tratamento de colises (figura abaixo), as entradas da tabela de disperso possuem
um apontador para uma lista encadeada cujos elementos armazenam as chaves que geram o
endereo da entrada (e eventualmente a informao associada). Tambm possvel
implementar tratamento de hashing por encadeamento sem usar alocao dinmica de
memria. Para isso, acrescenta-se a cada entrada da tabela um campo que indica a prxima
entrada a ser pesquisada se a entrada no contiver a chave que deveria conter e que foi
deslocada por causa de uma coliso.
Em alguns casos entradas extras se encontram na rea separada da tabela chamada rea de
overflow.
20
Chave
K=ord(chave) i1 = h(K)
i2 = rh(i1)
i3 = rh(i2)
C
67
4
H
72
2
A
65
2
3
V
86
2
3
4
E
69
6
S
83
6
0
A figura a seguir mostra a distribuio destas chaves na tabela de disperso.
i4 = rh(i3)
Tabela
0
1
2
3
4
5
6
S
H
A
C
V
E
21
22
Procure a ocorrncia do elemento a partir de d(x), ate que o elemento seja encontrado
ou que uma posio vazia seja encontrada.
Implementao
public void adicionar (Produto marca); // adicionar um elemento na tabela de disperso
public void remover (Produto marca); // remover um elemento na tabela de disperso
public boolean contem (Produto marca); // verificar se um elemento est na tabela de disperso
rvore
Uma rvore, considerada uma estrutura de dados contendo um nmero finito de elementos
que pode estar vazia ou particionada em subconjuntos. O primeiro subconjunto contm um
nico elemento chamado raiz. Os outros subconjuntos so, em si mesmo rvores, chamados
sub-rvores.
23
rvores de r, ou simplesmente sub-rvores, cada qual por sua vez uma rvore.
Ramos da rvore
Profundidade de um n
Profundidade da raiz 0
Profundidade de um n 1 + a profundidade do seu pai
Altura de um n
u antepassado de v
v descendente de u
24
rvores Binrias
Uma rvore binria T um conjunto finito de elementos denominados ns ou vrtices, tal
que:
- T = 0 e a rvore dita vazia, ou
- Existe um n especial r, chamado raiz de T, e os restantes podem ser divididos em dois
subconjuntos disjuntos, Tr E e Tr D, a sub-rvores esquerda e a direita de r, respectivamente,
as quais so tambm rvores binrias.
A raiz da sub-rvore esquerda (direita) de um n v, se existir, denominada filho esquerdo
(direito) de v. Naturalmente, o esquerdo pode existir sem o direito e vice-versa. Se r a raiz
de T, diz-se, tambm, que Tr E e Tr D so as sub-rvores esquerda e direita de T,
respectivamente.
Uma rvore binria pode ter duas sub-rvores vazias (a esquerda e a direita). Toda rvore
binria com n ns possui exactamente n + 1 sub-rvores vazias entre suas sub-rvores
esquerdas e direitas.
Percorrer rvores
Os elementos de uma rvore (binria) podem ser enumerados por quatro ordens diferentes. As
trs primeiras definem-se recursivamente:
Pr-ordem: Primeiro a raiz, depois a sub-rvore esquerda, e finalmente a sub-rvore direita
Em-ordem: Primeiro a sub-rvore esquerda, depois a raiz, e finalmente a sub-rvore direita
Ps-ordem: Primeiro a sub-rvore esquerda, depois a sub-rvore direita, e finalmente a raiz
25
Operaes:
Criar uma rvore vazia
Determinar se uma rvore est vazia
Criar uma rvore a partir de duas sub-rvores
Eliminar os elementos da rvore (esvaziar a rvore)
Definir iteradores para percorrer a rvore
Imprimir uma rvore
N da rvore binria
Template <class T> class BTNode {
T element;
BTNode<T> *left, *right;
friend class BinaryTree<T>;
friend class BTItrIn<T>;
friend class BTItrPre<T>;
friend class BTItrPos<T>;
friend class BTItrLevel<T>;
public:
BTNode(const T & e, BTNode<T> *esq = 0, BTNode<T> *dir = 0)
: element(e), left(esq), right(dir) {}};
26
Complexidade Algoritmica
Anlise de Algoritmos a rea da computao que visa determinar a complexidade (custo) de
um algoritmo, o que torna possvel:
Comparar algoritmos
Determinar se um algoritmo timo.
Chave encontrada!
~
Ordenao de Dados
Ordenao o acto de se colocar os elementos de uma sequncia de informaes, ou
dados, numa relao de ordem predefinida.
Algumas ordens so facilmente definidas. Por exemplo, a ordem numrica, ou a ordem
alfabtica crescentes ou decrescentes. Contudo, existem ordens, especialmente de dados
compostos, que podem ser no triviais de se estabelecer.
Um algoritmo que ordena um conjunto, geralmente representado num array, chamado
de algoritmo de ordenao. Algoritmo de ordenao em cincia da computao um
algoritmo que coloca os elementos de uma dada sequncia numa certa ordem, em outras
palavras, efectua sua ordenao completa ou parcial. As ordens mais usadas so a
numrica e a lexicogrfica. Existem vrias razes para se ordenar uma sequncia, sendo
uma delas, a possibilidade se aceder seus dados de modo mais eficiente.
Entre os mais importantes, podemos citar bubble sort
Ordenao - Tipos
Ordenao Interna
Todas as chaves na memria principal facilidade de acesso.
Ordenao externa
Chaves na memria principal e em memria externa movimentao de chaves entre as duas.
Diferentes mtodos para cada tipo.
A Ordenao por Seleco utiliza um o conceito de "selecionar o elemento
mais apto".
Ele seleciona o menor ou maior valor do array e passa para a primeira.
Ordenao por Bol
Concluso
Neste trabalho abordamos os conceitos por nos estudados durante as aulas de EDA. Este
trabalho foi realizado sobre a orientao do docente que deu-nos a oportunidade de
escolhermos o tema para a pesquisa. A escolha do sistema de gesto de clnicas foi devido a
capacidade que temos de arranjar o material para a pesquisa, visto que todos nos j passamos
por um hospital e verificamos que existe uma demora no atendimento em si. O nosso sistema
vem tentar suplantar esses problemas, pois o sistema tem como funo registar o medico,
29
paciente e o funcionrio guardando esses dados em arrays, vectores, listas, fila, pilhas, tabelas
de dispersao aps o registo tanto o paciente como os funcionrios so atribudos cdigos que
devem possibilitar localizar os seus processos em pouco tempo.
Bibliografia
FJ-11: Java e Orientao Objetos. http://www.caelum.com.br.
Uso do material disponibilizado pelo professor.
KATHY SIERRA ET AL. Use a Cabea: Java. Alta Books, 2007;
EIJE Albert, DE BARROS Cludio, KOJIIO Miguel, etal: Curso Java Starter, pp 4.
30
31