Indice

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

O nosso casso de estudo centra-se em:

Desenvolver um sistema de control de produtos capaz de dar suporte aos seguintes
problemas:
Segundo os fornecedores, existe na Fabrica vrios tipos de produtos: Coca, Fanta, Sprite,
Tnica etc.
Todas marcas possuem um nome, validade, cdigo e marca. Os produtos da Coca-cola,
possuem a mesma marca, oque facilita identificar a sua provenincia. Cada produto tem a sua
data de validade e cdigo, isto vai facilitar na configurao do sistema no nosso cdigo de
barra. Todas vez que se efectuar uma compra, saberemos que tipo de produto esta a ser
comprado, a validade e cdigo.
Foram tambm criados classes para verificao simples dos produtos usando Arrays, Vectores
e Listas. Nestas classes tambm foram criados mtodos que permitem adicionar, remover,
inserir, est vazio nas posies inumeradas.

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

A inicializao de um array se d atravs da instruo new. No exemplo acima, criamos um

array de tamanho 10, ou seja, teremos 10 posies para armazenar valores do tipo int.
int [] numeros;
String [] nomes;
Double [] notas;

O int o tipo de dado que ser armazenado pelo array.

[] - Informa que a varivel ser um array.
Numero - indicador de varivel.
New - instancia um novo objecto.
5

Int - informa o tipo do novo objecto.

[10] - Informa a quantidade das posies do array.
Inserindo valores de um array
Existem diversas formas de inserirmos valores em um array. A forma mais comum a
seguinte:
1.
2.
3.
4.

int [] numero = new int [3];

numero [0] = 124;
numero [1] = 43;
numero [2] = 1023;

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.

Acessando os valores de um array

Para acessarmos o valor armazenado em uma das posies de um array, basta conhecermos o
ndice de tal posio.
Exemplo:
int [] numro = new int [] {3215 , 754 , 23};
System .out . println (" Valor na posio de ndice 0: " + numero [0]) ;
System .out . println (" Valor na posio de ndice 2: " + numero [2]) ;
Percorrendo um Array
Uma maneira de percorrer um array com um ciclo while a outra, ligeiramente mais
simples, com a sintaxe alternativo de um ciclo for.
Usando while para percorrer um Array
String[] produtos = {"agua", "coca-cola"};
Int pos = 0;

while (pos<produtos.length){
System.out.println(produtos[pos]);pos++;
}

Usando o ciclo for para percorrer um Array

Public class ImprimeArray{
Public static void main (String [] args){
String [] produtos = new String [10];
for(int i=0; i<10; i++){
produtos[i]=i*10;
}
for(int i=0; i<10; i++){
System.out.println(produtos[i]);
}}
}

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

2. Reservar espao de memria e definir o tamanho. preciso definir o tamanho do

vetor, isto , a quantidade total de elementos que ter de armazenar. Em seguida
necessrio reservar espao de memria para armazenar os elementos.
3. Armazenar elementos no vector ou array. Para armazenar uma informao em um dos
elementos de um vetor ou matriz, necessrio fornecer um ndice que indique a
posio desse elemento.

Como podemos observar, os ndices comeam em zero e vo at o nmero de posies

reservadas, menos um. No vetor nota criado acima, os ndices vlidos vo de 0 at 69. Caso
haja a tentativa de atribuir um valor a um elemento cujo ndice esteja fora desse intervalo,
ocorrer um erro que impedir a execuo do programa. Por isso, necessrio um certo
cuidado ao manejar com esses ndices, garantindo o perfeito funcionamento do programa.
Existe um atalho para esses trs passos quando desejamos criar um vector com valores
atribudos de modo esttico. Foi o que fizemos no primeiro exemplo acima, declarando o
vetor nota com as notas de cinco alunos. Nesse caso o espao suficiente para as notas de
cinco alunos foi reservado e as notas foram guardadas em respectivas posies do vetor.

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:

Lista simplesmente encadeada e no ordenada;

Lista simplesmente encadeada e ordenada;
Lista duplamente encadeada e no ordenada;
Lista duplamente encadeada e ordenada;
Listas circulares.
9

Lista simplesmente encadeada e no ordenada

Nesta estrutura, cada elemento armazena um ou vrios dados e um ponteiro para o proximo
elemento, que permite o encadeamento e mantm a estrutura linear.
Lista simplesmente encadeada e ordenada
Nesta estrutura, cada elemento armazena um ou vrios dados e um ponteiro para o proximo
elemento, que permite o encadeamento e mantm a estrutura linear. Tem -se tambm um
campo denominado chave atravs do qual uma determinada ordenao mantida.
Representao de uma lista Simples

Lista duplamente encadeada e no ordenada

Nesta estrutura, cada elemento armazena um ou vrios dados e os dois ponteiros; o primeiro
para prximo elemento, e o segundo para o elemento anterior. Estes ponteiros permite o
duplo encadeamento e mantm a estrutura linear.

Lista duplamente encadeada e ordenada

Nesta estrutura, cada elemento armazena um ou vrios dados e os dois ponteiros; o primeiro
para prximo elemento, e o segundo para o elemento anterior, permitindo o duplo
encadeamento e mantm a estrutura linear. Tem -se tambm um campo denominado chave
atravs do qual uma determinada ordenao mantida.
Representao de uma lista dupla

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:

Operaes sobre listas

Tal como para todos os tipos de dados, as listas tambm tm um conjunto de operaes que
so usadas para manipular os seus dados. As operaes sobre listas so:

Criar lista vazia;

Inserir um elemento no fim da lista;
Inserir um elemento numa posio concreta da lista;
Mostar o elemento duma posio especifica da lista;
Remover um elemento da lista;
Mostrar o tamanho da lista;
Exibir um elementos duma lista;
Procurar a posio dum elemento na lista;
Concatenar duas lista

Implementao de Listas
public boolean estaVazia();
public void inserirFim (Produto str);
public Produto removerFim();
public void inserirInicio(Produto str);

11

public Produto removerInicio();

public void inserirPosicao(Produto str, int pos);
public Produto removerPosicao(int pos);
public void imprimir();

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.

Representao de uma fila

Podemos representar a fila de duas formas: representao sequencial e representao ligada.
Na representao sequencial usa-se um array, o que faz com que a capacidade da fila seja
fixa, enquanto na representao ligada, usa-se lista simples.

12

Representao da Fila

Operaes que formam a interface de uso de Fila

As filas apresentam operaes bsicas que so:
Verificar se a fila est ou no vazia. empty()
Inserir um novo elemento na fila. enqueue()
Remover o elemento que est na frente da fila. dequeue()
Devolver o tamanho da fila. getSize()
Mostrar o contedo da fila. print()

A fila pode ser implementada de duas maneiras: a primeira usando a estrutura esttica
13

Array e a outra fazendo o uso da estrutura dinmica lista.

Implementao usando Array
Na implementao de fila usando a estrutura esttica, um Array deve ser definido para
represent-la.
public class FilaArray implements Fila {
Produto p[];
int frente, cauda;
public FilaArray (int capacidade){
p= new Produto [capacidade];
frente= 0; cauda=0;
}
public boolean estaVazia() {
return cauda==frente;
}
public void enqueue(Produto str) {
p[cauda]=str;
cauda ++;
}
public Produto dequeue() {
Produto temp= p[frente];
frente++;
return temp;
}
public int obterTamanho() {
return cauda - frente;
}
public void Imprimir() {
for(int i=frente; i<cauda; i++){
System.out.println(p[i]);
}}}

Implementao usando Listas

14

public class FilaLista implements Fila {

Nodo frente, cauda;
int numElem;
public FilaLista() {
frente = new Nodo(null);
cauda = new Nodo(null);
numElem = 0;
}
public boolean estaVazia() {
return frente.getNext() == null;
}
public void enqueue(Produto str) {
Nodo novo = new Nodo(str);
if (estaVazia()) {
frente.setNext(novo);
cauda.setNext(novo);
} else {
cauda.getNext().setNext(novo);
cauda.setNext(novo);
}
numElem++;
}
public Produto dequeue() {
Nodo temp = frente.getNext();
frente.setNext(frente.getNext().getNext());
if (frente.getNext() == null) {
cauda.setNext(null);
}
numElem--;
return temp.getDado();
}
public int obterTamanho() {
return numElem;
}
public void Imprimir() {
15

Nodo actual = frente;

while (actual.getNext() != null) {
actual = actual.getNext();
System.out.println(actual.getDado());
}}}

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

Operaes sobre Pilhas

Nas pilhas, operaes de insero e eliminao so comummente citadas como operaes
"push" e "pop", respectivamente. O nico elemento directamente acessvel de uma pilha seu
elemento superior. O elemento menos acessvel seu elemento inferior.
Desde que as operaes de insero e eliminao sejam executadas na mesma extremidade da
pilha (extremidade superior), os elementos podem ser removidos somente na ordem oposta a
que foram inseridos.

Verificar se a pilha est ou no vazia. Empty()

Inserir um novo elemento na pilha. Push()
Remover o elemento que est no topo da pilha. Pop()
Devolver o elemento que est no topo da pilha, Top()
Devolver o tamanho da pilha getSize()
Mostrar o contedo da pilha. Print()

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.

Funes de Transformao de Chaves

Seja uma tabela de disperso com M entradas. Uma funo de transformao deve gerar para
cada elemento de um conjunto de chaves um valor entre 0 e M-1 correspondente a um
endereo na tabela.
Como a transformao da chave uma operao aritmtica, preciso, no caso da chave ser
composta de caracteres, gerar um valor numrico equivalente atravs da soma dos valores na
tabela ASCII dos caracteres que compe a chave. A seguir, K usado para gerar o endereo
para a tabela atravs de uma funo de transformao h(K). esperado que h(K) seja uma
funo que produza um baixo nmero de colises ao mesmo tempo em que tenha um bom
grau de "espalhamento", ou seja que os endereos sejam uniformemente gerados. Alm disso,
importante que a funo seja simples de calcular. Embora o conhecimento do conjunto de
chaves possa ajudar bastante na escolha da funo, vrios autores indicam que uma boa
19

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

Endereamento Aberto (ReHash)

Para evitar o uso de recursos adicionais na construo da estrutura de dados, a estratgia de
endereamento aberto simplesmente aplica outra funo de transformao de chave quando
houver uma coliso causada pela funo original h(K).
Assim, se h uma coliso causada por h(k) usa-se uma outra funo rh(h(K)) que determina
outra entrada onde a chave deve ser inserida. Se houver outra coliso usa-se rh(rh(h(K))) e
assim por diante. Se no encontrada nenhuma
posio vazia porque a tabela j est cheia e no podem ser includos novos elementos. A
busca da chave segue a
mesma estratgia.
Uma das alternativas mais usadas para a gerao das entradas alternativas chamada hashing
linear, onde a posio na tabela dada por:
rh(i) = ( i + 1 ) % M
Suponha por exemplo que desejamos inserir, na ordem em que aparecem de cima para baixo,
as seguintes chaves em uma tabela com M=7:

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

Contudo, h um problema gerado com o espalhamento linear: quando h um conjunto com

muitas entradas contguas preenchidas, este apresenta mais chances de promover uma
insero que outro com entradas mais dispersas.
Este fenmeno em que duas chaves espalhadas em dois valores diferentes competem entre si
em sucessivos rs espalhamentos chamado de agrupamento primrio. Existem vrios
mtodos que resolvem o problema do agrupamento primrio. Contudo, eles no eliminam um
outro fenmeno, conhecido como agrupamento secundrio, no qual chaves diferentes que
espalham o mesmo valor seguem o mesmo percurso de r espalhamento. Uma maneira de
eliminar todo esse agrupamento o espalhamento duplo, que detalharemos a seguir.
Espalhamento Duplo
O espalhamento duplo aparece como soluo aos problemas do agrupamento primrio e
agrupamento secundrio. Para us-lo precisamos de duas funes, isso permite que os
resultados da funo hash se aproximem de permutaes aleatrias. Veja a seguir as funes
hash definidas para atender aos requisitos do espalhamento duplo.
Para o primeiro clculo:
h(K) = K % M
Caso haja coliso, inicialmente calculamos h2(K), que pode ser definida como:
h2(K) = 1 + ( K % (M-1) )
Em seguida calculamos a funo rehash como sendo:
rh(i,K) = ( i + h2(K) ) % M
Veja o seguinte exemplo: suponha uma tabela com 10 entradas (M = 10), todas inicialmente
vazias. A insero do valor 35 ser feita na posio 5, pois:
h(35) = 35 % 10 = 5
A insero, em seguida, do valor 65 ser calculada da seguinte maneira:
h(65) = 65 % 10 = 5 (coliso)
h2(65) = 1 + ( 65 % (10-1) ) = 3
rh(5,65) = (5 + 3) % 10 = 8
Portanto, 65 ser inserido na posio 8 da tabela.
Operao de Busca

Suponha que uma chave x for mapeada pela funo de disperso d

22

Para um determinado ndice d(x)

Procure a ocorrncia do elemento a partir de d(x), ate que o elemento seja encontrado
ou que uma posio vazia seja encontrada.

Entrada: a tabela e a chave de busca

Sada: o ponteiro do elemento, se encontrado NULL, se o elemento no for

encontrado.

Operao de insero e modificao

Suponha que uma chave x for mapeada pela funo de disperso d para um
determinado ndice d(x).
Procure a ocorrncia do elemento seja encontrado ou que uma posio vazia seja
encontrada
Se o elemento existir, modifique o seu contedo

Se no existir, insira um novo na primeira posio livre que encontrar na tabela, a

partir do ndice mapeado.

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

public void imprimir(); //imprimir o contedo da tabela de disperso

public int getTamanho(); // devolver tamanho da 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

Uma rvore enraizada T, ou simplesmente rvore, um conjunto finito de elementos

denominados ns ou vrtices, tais que:
T = 0, e a rvore dita vazia, ou
Existe um n especial, r, chamado raiz de T; os restantes constituem um nico
conjunto vazio ou so divididos em m 1 conjuntos disjuntos no vazios, as sub

rvores de r, ou simplesmente sub-rvores, cada qual por sua vez uma rvore.
Ramos da rvore

rvore de N ns tem N-1 ramos

Profundidade de um n

Comprimento do caminho da raiz at ao n

Profundidade da raiz 0
Profundidade de um n 1 + a profundidade do seu pai
Altura de um n

Comprimento do caminho do n at folha a maior profundidade

Altura de uma folha 0

Altura de um n 1 + a altura do seu filho de maior altura

Altura da rvore: altura da raiz

Se existe caminho do n u para o n v

u antepassado de v
v descendente de u

Tamanho de um n: nmero de descendentes

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

 Por nvel: Os ns so processados por nvel (profundidade) crescente, e dentro de cada

nvel, da esquerda para a direita.

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

rvores binrias de pesquisa

Estrutura linear com elementos ordenados
A pesquisa de elementos pode ser realizada em O(log n)
Mas no insero ou remoo de elementos

26

 Estrutura em rvore binria

Pode manter o tempo de acesso logartmico nas operaes de insero e remoo de
elementos
rvore binria de pesquisa
Mais operaes do que rvore binria bsica: pesquisar, inserir, remover
Objectos nos ns devem ser comparveis (Comparable)
Pesquisa
Usa a propriedade de ordem na rvore para escolher caminho, eliminando uma subrvore a cada comparao
Insero
Como pesquisa; novo n inserido onde a pesquisa falha
Mximo e mnimo
Procura, escolhendo sempre a sub-rvore direita (mximo), ou sempre a sub-rvore esquerda
(mnimo)
Remoo
N folha: apagar n
N com 1 filho: filho substitui o pai
N com 2 filhos: elemento substitudo pelo menor da sub-rvore direita (ou maior da
esquerda); o n deste tem no mximo 1 filho e apagado.

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.

Tipos de Avaliao de Algoritmos

A avaliao de algoritmos divide-se em dois tipos a saber:

Avaliao Emprica: a forma mais simples de se avaliar um algoritmo e consiste

27

implement-lo num computador e execut-lo com vrias instncias do problema.

Define-se ento um critrio para a eficincia, como por exemplo o tempo gasto para
execuo. Com base na observao, pode-se

calcular o pior caso (a

instncia de execuo que levou mais tempo), o melhor caso (a instncia

de execuo gastou menos tempo) e o caso mdio (a medida do tempo
gasto em todas as instncias da execuo).
O problema com esse tipo de avaliao que o tempo gasto vai depender
do computador usado, do compilador, da linguagem de programao;

Avaliao Terica: aquela em que consiste em encontrar uma frmulmatemtica que

expresse o recurso, por exemplo o tempo necessrio para algoritmo executar em
funo do tamanho dos dados de entrada.

Existem algumas notaes predefinidas usadas para comparar diferentes funes:

Metodos de Pesquisa de Dados

Conceito
pesquisa de dados e o mtodo de procura de um certo dado (ou conjuto
de dados) seguindo um determinado algoritmo.
Tipos de pesquisa de dados
Existem dois tipos de pesquisa: a sequencial e a binria. Antes de
estudarmos cada um
destes tipos de pesquisa, analisemos o seguinte problema:
Dada uma coleco de n elementos, pretende-se saber se um
determinado elemento x
existe nessa coleco. Para efeitos prticos, vamos supor que essa
coleco implementada como sendo um array a[0...n-1] de n elementos
inteiros.
Pesquisa Sequencial
Mtodo intuitivo:
Dada uma chave k, compar-la a cada chave no vetor, caso haja uma igual, a chave est no
vetor
Caso todas as chaves tenham sido comparadas e no houve nenhuma igual, a chave no
existe no vetor.
k=8
42 16 4 15 8 23
28

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