Algoritmos e Estruturas de Dados 02

- Listas
- Conceitos Gerais
- Uma lista � uma estrutura de dados que agrupa informa��es
referentes a um conjunto de elementos que de
alguma forma se relacionam entre si. (Ela oferece uma forma
simples de interligar os elementos
do conjunto)
- Cada n� da lista � formado por diversos atributos. Geralmente
um desses atributos atua como
identificador do n�. (Uma lista linear cada n� � formado
por campos que armazenam as
caracteristicas distintas dos elementos da lista, al�m
disso, cada n� da lista possui um
identificador. Por exemplo um aluno tem nome, matricula,
telefone, etc.)
- As listas podem ser mantidas na mem�ria do computador das
seguintes formas:
- Aloca��o sequencial
- Aloca��o encadeada
- Aloca��o Sequencial (Forma mais simples de manter os elementos de uma
lista na mem�ria)
- Na aloca��o sequencial, os elementos da lista ficam dispostos
de forma cont�gua na mem�ria.
- A implementa��o da aloca��o sequencial � geralmente realizada
com a reserva pr�via de mem�ria
(por isso a aloca��o sequencial � considerada uma aloca��o
est�tica).
- Possibilita acesso imediato a um elemento da lista. (Aloca��o
sequencial permite isso).
- Ex: os vetores auxiliam a implementa��o de uma lista
sequencial.
- Representa��o de uma lista com aloca��o sequencial
|N� 1|N� 2|N� 3|N� 4|N� 5|N� 6|N� 7|
Cada n� com campos |Matricula|Nome|Endere�o|
Aqui temos 7 alunos com seus atributos. Matricula seria o
atributo identificador dos n�s.

- Aloca��o Sequencial � Opera��o Busca

- Para buscar um elemento em uma lista linear com aloca��o
sequencial, podemos usar os seguintes
m�todos: (Dois m�todos detalhados no primeiro m�dulo sendo
a bin�ria mais eficiente. A bin�ria
precisa que os elementos estejam ordenados e exige
que a estrutura que ela ser� aplicada
forne�a acesso direto ao elemento)

-Busca sequencial
-Busca bin�ria

- Como encontrar o n� com identificador 30 na lista a

seguir?
|02|10|30|01|56|08|26|
Pode-se verificar que essa lista n�o est� ordenada.
Assim, nao podemos usar a busca
bin�ria, temos que usar a busca sequencial.
A busca sequencial procura, a partir do primeiro
elemento, um por um at� encontrar o
elemento.
 - Aloca��o Sequencial � Opera��o Inclus�o
- Considerando uma lista inicialmente vazia, como a mesma
ficaria ap�s a inclus�o dos seguintes
elementos: 2, 10, 30, 1, 56?

Primeiramente inclui o 2 na lista no primeiro espa�o vago a

o atributo ULTIMO aponta para esse
indice 1 (array come�a em 1). Depois o 10 � inserido no
pr�ximo espa�o e incrementa o
atributo ULTIMO. Assim, |02|10|30|01|56| | |
Essa complexidade � O(1), constante.

Acima os elementos foram incluidos sem crit�rio, uma

segunda vers�o seria a inclus�o em
ordem. Nesse caso, talvez tenhamos que abrir espa�o
deslocando todos os elementos para frente
uma posi��o.

- Considerando uma lista inicialmente vazia, como a mesma

ficaria ap�s a inclus�o dos seguintes
elementos de forma a manter a lista ordenada: 2, 10, 30, 1,
56?

Devemos seguir os passos:

1 � Identificar onde o novo elemento deve ser inclu�do
2 � Deslocar todos os elementos para frente (inclusive)
3 � Incluir o novo elemento

Assim, primeiramente introduzimos o 2 na primeira posi��o e

atualizamos o ULTIMO para esse
primeiro indice.
Agora o 10 identificamos que ele deve ser inclu�do ap�s o
2, n�o precisa deslocar. Apenas
inclu�mos o elemento: |02|10| | | | | |
O elemento 30 � inclu�do ap�s o 10, assim: |02|10|30| | | |
|
O elemento 1 deve ser inclu�do na primeira posi��o, devemos
deslocar todos os elementos
para frente: | |02|10|30| | | | Ap�s isso basta incluir o
2: |01|02|10|30| | | |
Por fim, o 56 deve ser inclu�do na �ltima posi��o: |01|02|
10|30|56| | |

Essa complexidade � de O(n) devido os deslocamentos pra

deixar a lista ordenada.

- Aloca��o Sequencial � Opera��o Remo��o

- Considerando a lista a seguir, como remover os elementos
56 e 2?
|01|02|10|30|56| | |

ultimo = 56;

Devemos seguir os passos:

1 � Identificar onde se encontra o elemento a ser removido
2 � Remove o elemento
3 � desloca os seus sucessores
 Assim, usamos a busca sequencial ou bin�ria para localizar
o elemento a ser removido.
Nesse caso, encontra-se o 56 com a busca bin�ria visto que
est� ordenado. Como o �ltimo elemento
n�o tem sucessor n�o precisa deslocar nada.
O pr�ximo � o 2, identifica-se, remove-se o elemento e
verificamos que temos um burado
na lista: |01| |10|30| | | |
Agora � efetuado o deslocamento dos elementos para a
direita: |01|10|30| | | | |

- Aloca��o Encadeada:
- Na aloca��o encadeada, os n�s da lista s�o alocados/desalocados
de acordo com a necessidade (aloca��o
din�mica). Diferente da sequencial que o espa�o �
previamente alocado, aqui n�o sabemos com
antecedencia a quantidade de elementos da lista, conforme a
necessidade aloca-se espa�o.
- Os n�s da lista ficam dispostos aleatoriamente na mem�ria. Os
mesmos s�o interligados pela refer�ncia
que um n� faz ao seu sucessor.
- Quando comparado com a aloca��o sequencial, esses atributos
extras fazem com que essa estrutura tenha
um consumo maior de mem�ria. (Como cada n� deve saber o seu
sucessor temos que ter mais um
atributo para referenci�-lo)
- Estrutura m�nima de um n� na linguagem java: (um n� tem que ter
minimamente um id que o diferencia dos
demais e uma referencia para o pr�ximo)
class No {
private int id;
private No proximo;

//outros atributos

//construtores e m�todos de acesso

}

- Lista Simplesmente Encadeada (Sempre temos uma referencia para

o primeiro n� e a partir deste cada
um vai referenciar os seus sucessores. O �ltimo n�
referencia null.)
- Cada n� necessita de um atributo extra que tem como
objetivo referenciar o pr�ximo n� da lista.
|N� 1| | -> |N� 2| | -> |N� 3| | -> |N� 4| |
- Essa estrutura n�o permite acesso direto a um n� da
lista.

- Lembrando que um Tipo de Dados Abstrato (TAD) tem a

estrutura do dados e as opera��es.
Aqui teremos um TAD do tipo lista onde a estrutura do dados
pode ser um vetor na qual utiliza-se
aloca��o sequencial ou poder�amos utilizar a aloca��o
dinamica. Para manipular essa estrutura
ter�amos as opera��es que � a forma como o user do TAD
manipula a estrutura.

- Defini��o das principais opera��es: (interface com o

mundo seria abaixo, as opera��es que
 podem ser feitas em cima da lista)

interface IListaEncadeada {
void insere(No elementoAnterior, No
novoElemento);
No busca(int idProcurado);
void remove(int idNoRemovido);
}

- Lista Simplesmente Encadeada � Opera��o Inclus�o

- Implementa��o em java:
public void insere(No elementoAnterior, No
novoElemento) {
novoElemento.proximo =
elementoAnterior.proximo; //O elemento que sera
//inserido recebe quem o
elemento atual referencia como
//proximo
elementoAnterior.proximo = novoElemento;
//O elemento anterior agora
aponta para o novo inserido
//e o elemento que ele
apontava antes foi referenciado
//pelo novo elemento inserido
conforme realizado na
//opera��o acima
}

Ex: tendo a lista |02| | -> |04| | -> |08| | ->

|10| |
E efetuando a opera��o
listaEncadeada.insere(elementoAnterior4, elementoNovo6)
Queremos inserir o 6 depois do 4 que � o
elemento anterior a ele, ou seja entre 4
e o 8.
Executando a primeira instru��o do insere tem-
se que o 6 ainda n�o est� na lista
mas ele apontar� para o pr�ximo do elemento
anterior a ele, assim:
|06| | -> |08| | -> |10| | o 8 j� aponta para o
10 que aponta para null.
Agora executamos a �ltima atribui��o do insere
em que o 4 aponta para o 6:
|02| | -> |04| | -> |06| | -> |08| | -> |10| |

Podemos notar que � menos custoso que a

sequencial, visto que n�o � preciso
nenhum deslocamento.

- Lista Simplesmente Encadeada � Opera��o Busca

- Uma vez que a lista encadeada n�o permite acesso
direto a um n�, a mesma n�o admite a
busca bin�ria.
- Para buscar um n� em uma lista encadeada devemos
percorrer, a partir do primeiro
elemento, todos os demais at� encontrar o n�
desejado.
- Implementa��o em java:
public No busca(No primeiroNo, int idProcurado)
{
No item = primeiroNo;
//varre toda lista atras do item sendo
procurado. O != null � para
//o caso de n�o ter mais elementos na
lista, evita null pointer
while(item!=null && item.id !=
idProcurado) {
item = item.proximo;
}

return item;
}

- Lista Simplesmente Encadeada � Opera��o Remo��o

- Implementa��o da remo��o de um n� da lista:
public void remove(int idNoRemovido) {
//Trata o caso do primeiro n� ser o
removido. Simplesmente faz o primeiro
//referenciar o sucessor, assim perde-se
o primeiro e inicia-se a partir
//do segundo n�.
if (primeiroNo.id == idNoRemovido) {
primeiroNo = primeiroNo.proximo;
return;
}

//Trata os demais casos

No temp = primeiroNo;
while(temp!=null) {
No anterior = temp; //anterior � o
primeiro no
No posterior = temp.proximo;
//proximo elem ap�s o primeiro no

//veja que se quer remover o n�

posterior, o primeiro n� j� foi
//verificado na primeira comparacao
do algoritmo
if (posterior.id == idNoRemovido) {
anterior.proximo =
posterior.proximo; //o posterior �
//o pr�ximo depois do
primeiro no, e o anterior
//� o primeiro n� na
primeira iteracao
return;
}

temp = temp.proximo; //passa para o

proximo elemento a ser
//analisado
posteriormente
}
}

- Lista Simplesmente Encadeada � N� cabe�a

- A exist�ncia de um ponteiro referenciando o inicio
da lista obriga alguns algoritmos a
 apresentarem testes especiais na realiza��o de
suas opera��es. (ex � o primeiro
if do algoritmo anterior)
- Isso pode ser resolvido por uma pequena varia��o na
estrutura de armazenamento: a
cria��o de um n�-cabe�a, nunca removido, que
passa a ser o n� indicado pelo
ponteiro de inicio da lista. (Antes o primeiro
n� referenciava o primeiro
elemento da lista, agora n�o, agora o primeiro
ser� o n� cabe�a que independe
de qtos elemento tem na lista e nunca �
removido.)
- Esse n� especial n�o deve conter informa��es
relacionadas a tabela propriamente dita.
(Ele at� pode armazenar informa��es referente ao
algoritmo implementado, qtdade de elem
da lista, mas nada referente a tabela propriamente
dita.)
- O n� cabe�a tamb�m pode ser denominado sentinela ou
header.
|//| | -> |02| | -> |04| | -> |06| | -> |08| |
-> |10| |
Esse primeiro n� hachurado � o n� cabe�a que
aponta para o inicio da lista.
Se essa lista n�o tiver mais elementos ele
continua existindo, mas n�o teria
nenhum sucessor.
- Obs: (CESPE) Em algumas implementa��es, uma lista
vazia pode ter um �nico n�, chamado
de sentinela, n� cabe�a ou header. Entre suas
poss�veis fun��es, inclui-se
simplificar a implementa��o de algumas
opera��es realizadas sobre a lista, como
inserir novos dados, recuperar o tamanho da
lista, entre outras. (CORRETO -pois
o header dispensa alguns testes adicionais e
pode ter infos como o tam da lista)

- Lista Duplamente Encadeada

- S�o listas que possuem uma refer�ncia para o n�
predecessor e outra para o n� sucessor. (A lista
simplesmentes encadeada s� apontava para o sucessor)
- Essa adapta��o da estrutura possibilita que a lista seja
percorrida em ambas as dire��es. (A
lista simlesmente encadeada s� percorria em um
sentido)
- Comparada com a lista simplesmente encadeada, essa
estrutura possui um consumo de mem�ria
ainda mais elevado. (Temos agora o dobro de
referencias em cada n�)
____ _ ____ _ ____ _ ____ _
|N� 1| | -> |N� 2| | -> |N� 3| | -> |N� 4| |
|____|_| <- |____|_| <- |____|_| <- |____|_|

- Lista Circular
- Uma lista circular tem como particularidade seu �ltimo n�
referenciar o primeiro n� da lista.
(Agora o ultimo n� referencia o primeiro elemento e n�o
mais null)
- A lista circular pode ser simplesmente encadeada ou
duplamente encadeada. (abaixo a simplesmente
encadeada. Se fosse duplamente encadeada ter�amos que
apontar para o anterior, e o primeiro n�
tb referenciaria o �ltimo).
|N� 1| | -> |N� 2| | -> |N� 3| | -> |N� 4| |
^ |
|_______________________________________|

- Obs: Quando o n�mero de acessos rand�micos a uma �rea de

armazenamento � muito maior que o
n�mero de inser��es e remo��es de elementos
armazenados, a organiza��o dessa �rea de
armazenamento por meio de uma lista encadeada resulta
em desempenho melhor que o
apresentado por organiza��o feita mediante uma
estrutura de array. (ERRADO, array
permite acesso direto, sao mais eficientes nesse
cen�rio. As listas encadeadas s�o melhor
qdo temos mais inclusoes e exclus�es.)
- Obs 2: O tempo de busca de um elemento em uma lista
duplamente encadeada � igual � metade
do tempo da busca de um elemento em uma lista
simplesmente encadeada. (ERRADA - em
ambas as estruturas temos que buscar o elemento
percorrendo tudo, a complexidade � O(n))
- Obs 3: As listas duplamente encadeadas diferenciam-se das
listas simplesmente encadeadas pelo
fato de, na primeira, os n�s da lista formarem um
anel com o �ltimo elemento ligado ao
primeiro da lista. (ERRADA - isso � a circular)

- Pilhas
- Conceitos Gerais
- A pilha � uma estrutura de dados onde as inser��es e as
remo��es s�o realizadas em apenas um extremo.
(� como uma pilha de pratos, onde empilha-se e desempilha na
extremidade superior)
- O primeiro objeto a ser inserido na pilha � o �ltimo a ser
removido. Por trabalhar com essa pol�tica,
essa estrutura � conhecida como LIFO (last-in, first-out) -
ultimo incluido � o primeiro a ser retirado.
- Essa estrutura usa uma vari�vel de controle comumente chamada
de topo que referencia o �ltimo elemento
inserido na pilha.
- Principais opera��es de uma pilha
- Defini��o das principais opera��es.
interface IPilha {
public boolean isPilhaVazia(); //verifica se h� elem
na pilha, true ou false
public void push(Object elemento); //inclui novo
elemento no topo da pilha
public Object pop(); //remove um elemento do topo da
pilha
public Object peak(); //consulta o elemento que est�
no topo da pilha retorna o elem
 //do topo (diferente da anterior
que remove o que est� no topo)
}
- Opera��o isPilhaVazia
- Essa opera��o verifica se a pilha esta vazia.
- Implementa��o em java: (t�cnica de aloca��o sequencial
que se utiliza um vetor)
public boolean isPilhaVazia() {
return topo == -1; //topo aponta para o indice,
esse indice � invalido
}
- Opera��o push
- Essa opera��o insere um elemento no topo da pilha.
- Implementa��o em java:
public void push(Object elemento) {
//COMPRIMENTO_PILHA � o tamanho da pilha, faz
-1 por causa do indice 0
if (topo != COMPRIMENTO_PILHA-1) { //verifica
se a estrutura nao esta cheia
elementos[++topo] = elemento;
//incrementa o topo e armazena nesse indice
//do array o
elemento
} else {
System.out.println("Estouro de pilha:
OverFlow")
}
}

Como ficaria uma pilha, inicialmente vazia, ap�s a

inclus�o dos elementos: 2, 10, 30,
1, 56?
_______
|_______|
|_______|
|_______|
|_______|
|_______|
|_______|
<--topo

Ap�s a inclus�o do 2 atraves de um push(2)

teria-se:
_______
|_______|
|_______|
|_______|
|_______|
|_______|
|___2___| <--topo

Ap�s a inclus�o do 10 atraves de um push(10)

teria-se:
_______
|_______|
|_______|
|_______|
|_______|
|___10__| <--topo
 |___2___|

E assim por diante...

- Opera��o pop
- Essa opera��o remove o elemento do topo da pilha.
- Implementa��o em java:
public Object pop() {
if (!isPilhaVazia()) {
Object object = elementos[topo]; //pega
quem est� no topo
elementos[topo--] = null; //tira o
elemento do topo e decremento o topo
return object;
} else { //pilha vazia, tentou retirar elemento
de uma pilha sem elem
System.out.println("Estouro de pilha:
Underflow");
return null;
}
}

Como ficaria essa pilha ap�s a execu��o da opera��o

pop tr�s vezes seguidas?

_______
|_______|
|___56__| <--topo
|___01__|
|___30__|
|___10__|
|___2___|

Para pop(); pop(); pop(); Ter�amos:

_______
|_______|
|_______|
|_______|
|_______|
|___10__| <--topo
|___2___|

- Opera��o peak (alguns autores chamam de top)

- Essa opera��o permite consultar o elemento do topo da
pilha sem a remo��o do mesmo.
- Implementa��o em java:
public Object peak() {
if (!isPilhaVazia()) {
return elementos[topo];
}

return null;
}

Se uma pilha tem 56 no topo e fizermos peak() duas

vezes, ele retorna duas vezes o 56.

- Obs: Assinale a op��o correta relativa �s opera��es

b�sicas suportadas por pilhas.
 A) Push: insere um novo elemento no final da pilha. -
Ele faz isso no topo da pilha
B) Pop: adiciona elementos ao topo da pilha.
C) Pull: insere um novo elemento no interior da
pilha. - N�o existe essa operacao
D) Top: transfere o �ltimo elemento para o topo da
pilha.
E) Top: acessa o elemento posicionado no topo da
pilha. (CORRETO)
- Obs: Sobre pilhas � correto afirmar:
A) Uma lista LIFO (Last-In/First-Out) � uma estrutura
est�tica, ou seja, � uma cole��o
que n�o pode aumentar e diminuir durante sua
exist�ncia. (Depende da t�cnica de
implementa��o que pode ser dinamica)
B) Os elementos na pilha s�o sempre removidos na
mesma ordem em que foram inseridos.
(Na ordem INVERSA que foram inserido)
C) Uma pilha suporta apenas duas opera��es b�sicas,
tradicionalmente denominadas push
(insere um novo elemento no topo da pilha) e pop
(remove um elemento do topo da pilha).
(Faltou o peak ou top)
D) Cada vez que um novo elemento deve ser inserido na
pilha, ele � colocado no seu topo e,
em qualquer momento, apenas aquele posicionado no
topo da pilha pode ser removido.
(CORRETA)
E) Sendo P uma pilha e x um elemento qualquer, a
opera��o Push(P,x) diminui o
tamanho da pilha P, removendo o elemento x do seu
topo. (Push inclui um elem na pilha)
- Obs: O uso de aloca��o din�mica de mem�ria � essencial na
cria��o de uma pilha de dados. (ERRADA)
- Obs: Na representa��o f�sica de uma pilha sequencial, �
necess�rio uso de uma vari�vel
ponteiro externa que indique a extremidade da lista
linear onde ocorrem as opera��es de
inser��o e retirada de n�s. (CORRETO - Referencia-se
o topo da estrutura, o ultimo elem)

- Filas
- Conceitos gerais
- � uma estrutura de dados onde as inser��es s�o realizadas em um
extremo e as remo��es em outro.
(Semelhante a uma fila de um Banco, quem chega vai pro final da
fila e quem chegou primeiro ser�
atendido primeiro.)
- O primeiro objeto a ser inserido na fila � o primeiro a ser
removido da mesma. Por trabalhar com essa
pol�tica, essa estrutura � conhecida como FIFO (first-in,
first-out).
- Essa estrutura usa duas vari�veis de controle para referenciar
o inicio e o fim da fila.
- Principais opera��es de uma fila
- Defini��o das principais opera��es em java.
interface IFila {
public boolean isFilaVazia();
public void enfileirar(Object elemento); //inclui
elemento no fim da fila
public Object desenfileirar(); //remove elemento do
inicio da fila
}

- Opera��o isFilaVazia
- Essa opera��o verifica se a fila esta vazia.
- Implementa��o em java:
public boolean isFilaVazia() {
return (inicio == fim) && (fim == 0)
}

- Opera��o enfileirar
- Essa opera��o insere um elemento na fila.
- Implementa��o em java: (estrutura sequencial circular)
public void enfileirar(Object elemento) {
int posicao = (fim % COMPRIMENTO) + 1;
//posicao que devemos inserir o elem.
//poderiamos
simplesmente pegar o fim + 1 para
//inserir no fim da fila
o elemento. Mas como
//ela tem carater
circular fazemos esse calculo.
//Ex: | |10|30|01|56|
fazendo o calculo
//5%5=0(resto) + 1 = 1;
Insere na pos 1.

if (posicao != inicio) { //se a pos final

conflita com o inicio temos um estouro
fim = posicao;
elementos[fim] = elemento;
if (inicio == 0) {
inicio = 1; //posicao inicial
}
} else {
//overflow
System.out.println("overFlow");
}
}

Como ficaria uma fila, inicialmente vazia, ap�s a

inclus�o dos elementos: 2, 10, 30, 1, 56?
| | | | | | | | inicio = 0, fim = 0 (posicoes
iniciais)
fim%COMRPRIMENTO = 0%7 = 0+1 = 1, assim: |02| | | |
| | | inicio=1, fim=1
fim%COMRPRIMENTO = 1%7 = 1+1 = 2, assim: |02|10| | |
| | | inicio=1, fim=2
E assim por diante...

- Opera��o desenfileirar
- Essa opera��o remove um elemento da fila.
- Implementa��o em java:
public Object desenfileirar() {
Object elementoRecuperado = null;

if (!isFilaVazia()) {
 elementoRecuperado = elementos[inicio];
elementos[inicio] = null;

if (inicio == fim) { //qdo a lista tem um

elemento inicializa os controles
inicio = fim = 0;
} else {
inicio = (inicio % COMPRIMENTO) +
1; //recalcula o inicio
}
} else {
//underflow
System.out.println("underFlow");
}

return elementoRecuperado;
}

Como ficaria a fila a seguir ap�s desenfileirar 3

elementos?
|02|10|30|01|56| | |
inicio = 02
fim = 56

Ao remover 02 tem-se o inicio apontando para 10

(indice 2) e o fim para 56.

- Obs: A melhor defini��o para a estrutura de dados chamada FILA

�(s�o):
A) � uma estrutura de dados linear, que tamb�m pode ser
linear e din�mica. �
composta por n�s que apontam para o pr�ximo elemento.
(Ok, mas n�o � a melhor)
B) S�o estruturas baseadas no princ�pio FIFO (first in,
first out), em que os
elementos que foram inseridos no in�cio s�o os
primeiros a serem removidos. (CORRETA)
C) S�o estruturas baseadas no princ�pio LIFO (last in,
first out), na qual os dados
que foram inseridos por �ltimo na pilha ser�o os
primeiros a serem removidos. (� Pilha)
D) � uma estrutura de dados em que cada elemento tem um ou
mais elementos
associados. (� valida para t�cnica de aloca��o
dinamica)
E) S�o estruturas de dados lineares e est�ticas, isto �,
s�o compostas por um
n�mero fixo (finito) de elementos de um determinado
tipo de dados. O tempo de
acesso aos elementos � muito r�pido por�m, a remo��o
de elementos pode ser
custosa se n�o for desej�vel que haja espa�os
"vazios" no meio da estrutura.
(Filas n�o sao estruturas est�ticas, isso � uma
t�cnica que pode ser utilizada)
- Obs: No armazenamento de dados pelo m�todo FIFO (first in -
first out), a estrutura de dados �
representada por uma fila, em cuja posi��o final ocorrem
inser��es e, na inicial, retiradas.
 (CORRETO)

- Obs: Insira os dados de entrada numa fila. Em seguida retire

cada dado da fila e insira
numa pilha. Mostre a pilha. Depois retire os dados da pilha
e insira na fila. Mostre a
fila. Dados de entrada: 11, 12, 23, 14, 25, 50, 8, 18, 29,
10
As estruturas mostradas ficam:

I. Pilha: (topo) 10 - 29 - 18 - 8 - 50 - 25 - 14 - 23 - 12
- 11
II. Fila: (come�o) 11 - 12 - 23 - 14 - 25 - 50 - 8 - 18 -
29 - 10 (fim)
III. Fila: (come�o) 10 - 29 - 18 - 8 - 50 - 25 - 14 - 23 -
12 - 11 (fim)
IV. Pilha: (topo) 11 - 12 - 23 - 14 - 25 - 50 - 8 - 18 - 29
- 10
V. A fila mostrada fica com os elementos em ordem invertida
dos dados de entrada

Est� correto o que se afirma APENAS em

A) III e IV.
B) II e IV.
C) I, II e III.
D) I, III e V. (CORRETO)
E) I, IV e V.

Inserindo os dados na fila temos: 11|12|23|14|25|50|08|

18|29|10|
Agora precisamos colocar na pilha: 11|12|23|14|25|50|08|
18|29|10| Retira um a um do ini da fila
Agora tira da pilha e coloca na fila: 10|29|18|08|50|25|14|
23|12|11| Retira do topo que � 10

- Deque (Double ended queue)

- Conceitos gerais
- � uma estrutura de dados similar a uma fila, no entanto,
suporta inser��o e remo��o em ambas
extremidades da estrutura.
- Essa estrutura usa duas vari�veis de controle, uma para
referenciar o inicio e outra para referenciar
o fim da estrutura.
- Principais opera��es de um deque
- Defini��o das principais opera��es.
public interface IDeque {
void inserirPrimeiro(Object elemento); //insere no
inicio da estrutura
void inserirUltimo(Object elemento);
Object removerPrimeiro();
Object removerUltimo();
}
- Opera��o inserirPrimeiro
- Insere um novo elemento no inicio do deque.
Como ficaria um deque, inicialmente vazio, ap�s a
inclus�o dos
elementos: 2, 10 e 30?
 Primeiramente insere o elemento 2: |2| inicio = 1 e
fim 1, ambos apontam para ele.
Ap�s isso o 10 que insere antes do 2: |10| -> |2|
inicio 1, fim = 2
Ap�s isso 30 passa ser o primeiro: |30| -> |10| -> |
2| inicio 1, fim = 3

- Opera��o inserirUltimo (S� manipula a variavel de controle fim)

- Insere um novo elemento no fim do deque.
- Como ficaria o deque abaixo ap�s a inser��o dos
elementos: 4 e 6?
|30| -> |10| -> |02| inicio = 30, fim = 02
Assim |30| -> |10| -> |02| -> |04| -> |06|

- Opera��o removerPrimeiro
- Remove e retorna o primeiro elemento do deque.
- Como ficaria o deque abaixo ap�s a execu��o da opera��o
removerPrimeiro duas vezes?
|30| -> |10| -> |02| -> |04| -> |06|
Assim ap�s executar a fun��o removerPrimeiro ter�a-se
|10| -> |02| -> |04| -> |06|

- Opera��o removerUltimo
- Remove e retorna o �ltimo elemento do deque.

- Obs: Uma fila duplamente terminada, isto �, uma estrutura linear que
permite inserir e remover de ambos os
extremos � chamada
A) �rvore.
B) Shift-and.
C) Aut�mato.
D) Deque. (CORRETA)
E) Boyer-Moore

- Obs: No que se refere a estruturas de dados � INCORRETO afirmar:

A) Numa fila dupla, os elementos podem ser inseridos e removidos de
qualquer um dos extremos da fila. (CORRETA)
B) Em qualquer situa��o � poss�vel usar uma �nica fila dupla para
representar duas filas simples. (INCORRETA)
C) A implementa��o de uma fila dupla normalmente � mais eficiente com
uma lista duplamente encadeada que com
uma encadeada simples. (CORRETA - Imagine um elemento na ultima
posi��o, teriamos que percorre-la toda
para remove-lo com um lista simplesmente encadeada)
D) Pela defini��o de fila, se os elementos s�o inseridos por um extremo
da lista linear, eles s� podem ser
removidos pelo outro. (CORRETA - Definicao de uma fila simples)
E) Numa lista singularmente encadeada, para acessar o �ltimo nodo �
necess�rio partir do primeiro e ir seguindo
os campos de liga��o at� chegar ao final da lista. (CORRETO)

- �rvores (Antes estudamos estruturas lineares, onde cada elemento tinha um

seguinte)
- Defini��o
- Uma �rvore pode ser definida com um conjunto de n�s que se
relacionam de forma hier�rquica mantendo as
seguintes propriedades:
 - Caso a �rvore n�o possua nenhum elemento, ela �
considerada vazia.
- Se a �rvore n�o � vazia, ela tem um n� especial chamado
raiz que n�o possui pai.
- Todos os outros n�s, com exce��o da raiz, possuem um
�nico pai e zero ou mais filhos.
- Representa��es
- Representa��o hier�rquica (Forma mais utilizada para representa
�rvores)
A
B C
D E F G
- Diagrama de inclus�o (Mais utilizada para representar
conjuntos)
Formado atrav�s de subconjunto com A sendo um grande
conjunto (circulo), dentro dele tem o B
que tamb�m tem seu conjunto composto por D, E, F e C que
tem o seu subconjunto formado por
G.
- Par�nteses aninhados
( A ( B (D) (E) (F) ) ( C (G) ) )
- Conceitos gerais
- N�
- � um v�rtice ou elemento da �rvore. (uma �rvore � um
conjunto de n�s)
- Pai
- Todo n�, com exce��o do n� raiz, tem exatamente um pai.
- Filho
- � um descendente direto de um n�.
- Sub�rvore
- Cada filho de um n� da origem a uma sub�rvore. Os
princ�pios que se aplicam a uma �rvore
tamb�m se aplicam a qualquer uma de suas sub�rvores.
- N� folha (n� terminal)
- Nome dado ao n� que n�o tem filho.
- N� interior (n� n�o terminal)
- Nome dado ao n� que possui pelo menos um filho.
- Grau de um n�
- � indicado pelo n�mero de filhos que o n� possui. (Se o
n� tem dois filhos ele tem grau 2)
- Grau de uma �rvore
- � indicado pelo n� que tem o maior grau na �rvore. (Se
uma �rvore tem um n� com grau 2, outro
com grau 5 e outros com grau 10, dizemos que a �rvore tem
grau 10. Isso pq ele � o maior grau
na �rvore)
- N�vel de um n�
- � determinado pelo comprimento do caminho da raiz ao n�
espec�fico. A raiz tem n�vel 0 (zero).
(o filho da raiz tem nivel 1, o filho do filho da raiz tem
n�vel 2 e assim por diante)
- Caminho da �rvore
- � o nome dado a uma sequencia de n�s distintos tal que
existe sempre entre n�s consecutivos a
rela��o �� filho de� ou �� pai de�.
- Altura de um n�
- � o maior comprimento do n� at� a folha.
- Floresta
- Nome dado ao conjunto de zero ou mais �rvores.
 - Exemplifica��o dos conceitos, dada a �rvore abaixo:
A
B C
D E F G

O n� A � o �nico que n�o tem pai, assim � o raiz.

Os n�s D, E, F, G s�o folhas.
O grau da �rvore tem-se: B � grau 3, A � 2, C � 1, os n�s
D, E, F, G s�o folha e tem grau 0.
Quanto a altura tem-se A � 2, B e C � 1, os n�s D, E, F, G
� zero.
Quanto ao n�vel tem-se A n�vel 0, B e C tem nivel 1, e os
�ltimos elemento todos tem n�vel 3.
� interessante tra�ar uma linha horizontal na �rvore
para verificar o seu grau e come�a
a contar a partir do 0.

- �rvores Bin�rias (Em uma �rvore bin�ria cada n� pode ter no m�ximo
dois elementos)
- � uma �rvore que possui um n� especial chamado raiz e outros
dois n�s denominados sub�rvore esquerda e
sub�rvore direita.
- Classifica��o de �rvores bin�rias:
- �rvore estritamente bin�ria - � uma �rvore bin�ria em que
cada n� possui 0 ou 2 filhos. (Ou
teremos n�s folhas ou n�s com dois elementos)
/ |A| \
/ |B| \ |C|
/ |D| \ |E|
|F| |G|
- �rvore bin�ria completa � � uma �rvore bin�ria onde
somente os n�s do �ltimo ou do pen�ltimo
n�vel da �rvore podem ter uma sub�rvore vazia. Sempre
possui altura m�nima.
/ |A| \
/ |B| \ / |C| \
/ |D| \ |E| |F| |G|
|H| |I|
Os n�s F, G, H, e I possuem n�s folha, mas s� �
permitido nesses n�veis.
- �rvore bin�ria cheia � � uma �rvore bin�ria onde somente
o �ltimo n�vel pode ter uma sub�rvore
vazia. Sempre possui altura m�nima. Toda �rvore bin�ria
cheia � completa e estritamente bin�ria.
(Isso pq ela atende �s exigencias das outras �rvores)
/ |A| \
/ |B| \ / |C| \
/ |D| \ |E| |F| |G|
- �rvore ziguezague � s�o �rvores bin�rias que possuem
altura m�xima. Seus n�s interiores possuem
exatamente uma sub�rvore vazia. (Parece uma lista
encadeada)
|A|
\
|B|
\
|C|
\
|D|
 \
|E|

- �rvores Bin�rias - Implementa��o (Temos basicamente duas formas

de implementa��o)
- Aloca��o est�tica
- Implementa��o realizada com um vetor.
- O mapeamento da �rvore para o vetor ocorre a partir
do n�vel zero, seguindo pelo n�vel
1 e assim sucessivamente.
- Sempre iniciando pelo n� da esquerda. (esquerda
para direita)
- O vetor deve ter 2^(qtdN�veis) � 1 elementos.
- Ex:
/ |A| \
/ |B| / |C| \
|D| |F| |G|
Dado o c�lculo anterior tem-se 2^3-1 = 8-1 = 7,
assim um vetor com 7 elem.
| | | | | | | |

O mapeamento da �rvore come�a do n�vel 0 da

esquerda para direita.
Assim, come�amos com o n�vel 0: |A| | | | | | |
Ap�s isso, tem-se da esquerda p/ direita: |A|B|
C| | | | |
Por fim, os elementos do ultimo nivel: |A|B|C|
D|-|F|G| Veja que a parte
vazia do array � para mapear a sub�rvore
direita do elemento D.
- Aloca��o din�mica
- Implementa��o realizada com uma lista encadeada.
- Cada elemento da lista ser� formado pelos dados do
n� e a inclus�o de mais duas
refer�ncias: sub�rvore esquerda e sub�rvore
direita.
- Nessa representa��o teremos uma quantidade de
elementos na lista correspondente a
quantidade de n�s da �rvore. (na est�tica tem
que alocar previamente para os
elementos do vetor).
/ |A| \
/ |B| / |C| \
|D| |F| |G|
Assim, o A aponta para B e C, o B aponta para D
e assim diante. De repente usando
atributos como esquerda e direita que s�o
referencias para n�s.

- Percursos em �rvores bin�rias

- Ao percorrer uma �rvore fazemos uma visita
sistem�tica em cada um de seus n�s. (essa
visita pode ser alguma opera��o no n� como a
impress�o de um atributo, etc)
- A seguir as principais formas de se percorrer os
n�s de uma �rvore:
- Em-ordem
- Pr�-ordem
- P�s-ordem
 - Percursos em �rvores bin�rias � Em-ordem
- O percurso em ordem segue recursivamente os
seguintes passos para cada sub�rvore
da �rvore:
- Percorrer a sub�rvore esquerda em-ordem
- Visitar a raiz
- Percorrer a sub�rvore direita em-ordem
- Implementa��o em java: (Chamadas recursivas)
public void emOrdem(ArvoreBinaria no) {
if (no != null) {

emOrdem(no.subarvoreEsquerda);
visitar(no);
emOrdem(no.subarvoreDireta);
}
}

Dada a �rvore abaixo:

/ |A| \
/ |B| \ / |C|
|D| |F| |G|

Percurso Em ordem:
Primeiramente dado o elemento A entramos
no m�todo e de imediato
executamos o A.subarvoreEsquerda que � B.
Depois volta para o m�todo
e chamados o D que �
no.subarvoreEsquerda. Como D � folha e n�o tem filho
pulamos para a linha visitar(no) que � o
n� D e assim � o n� visitado de
fato, � o primeiro de fato visitado. Ap�s
isso, vamos para a pr�xima
execu��o que �
emOrdem(no.subarvoreDireita) que � folha, D n�o tem filho.
Portanto, voltamos na pilha para o
elemento B e seguindo o fluxo vamos
para a linha visitar(no) onde de fato
visitamos o elemento. Esse ent�o
� o segundo elemento visitado de fato.
Agora na linha
emOrdem(no.subarvoreDireita) tem-se que F
ser� passado. Assim, gera-se
mais um fluxo de execu��o e vamos de novo
para a execu��o do m�todo, por�m
este tamb�m � um n� folha, pula-se a
primeira linha e vai para o visitar
onde visitamos mais um elemento de fato.
Com isso como emOrdem que recebe
no.subarvoreEsquerda n�o tem elemento
voltamos na pilha de execu��o para B
que parou na linha
emOrdem(no.subarvoreDireita). Mais uma vez voltamos no
fluxo de execu��o e vamos para o A que
continua na linha visitar(no),
visto que toda subarvore esquerda j� foi
visitada. Assim, ap�s visitar
de fato A vamos para
emOrdem(no.subarvoreDireita) que possui C. Ap�s
 isso, voltamos novamente ao topo do
m�todo e tem-se a chamada
emOrdem(no.subarvoreEsquerda) que tem G e
que gera uma nova chamada ao
m�todo. Como G � folha ele vai para o
visitar que visita de fato o
elemento. Ap�s isso, elimina ele no fluxo
visto que n�o tem elemento na
direita. Volta para C e visitamos ele tb,
que de fato o visita. Como C
tb n�o tem direita encerramentos aqui a
execu��o.
Assim, a execu��o foi D B F A G C.
- Percursos em �rvores bin�rias � Pr�-ordem
- O percurso pr�-ordem segue recursivamente os
seguintes passos para cada
sub�rvore da �rvore:
- Visitar a raiz
- Percorrer a sub�rvore esquerda em pr�-
ordem
- Percorrer a sub�rvore direita em pr�-
ordem
- Implementa��o em java:
public void preOrdem(ArvoreBinaria no) {
if (no != null) {
visitar(no);

preOrdem(no.subarvoreEsquerda);

preOrdem(no.subarvoreDireita);
}
}

Dada a �rvore abaixo:

/ |A| \
/ |B| \ / |C|
|D| |F| |G|

Percurso Em ordem:
Primeiramente dado o elemento A entramos
no m�todo e de imediato visita
o n� de fato, assim imprime A, depois
passa para a linha preOrdem passando
a subarvoreEsquerda, volta a execu��o do
m�todo e de cara visita(no) que
tamb�m imprime B. Depois, novamente chama
a subarvore da esquerda que
volta a execu��o do m�todo e de cara
novamente imprime D. Como D � n�
folha e n�o tem subarvore direita nem
esquerda volta o fluxo de execu��o
em B. Como j� visitamos B e j� chamamos
preOrdem(no.subarvoreEsquerda)
chamamos preOrdem(no.subarvoreDireita)
que executa o topo do m�todo
de novo e visita F de cara. Como F tamb�m
� folha voltamos na pilha de
execu��o para B que j� chamou tudo, ent�o
volta para A que tamb�m j�
 foi visitado e j� chamou a parte da
subarvore esquerda e agora chama a
subarvore da direita. Assim, chama o
preOrdem(no.subarvoreDireita) que
� C que volta no todo do m�todo e de cara
chama visitar(no) e imprime
na tela C e chama
preOrdem(no.subarvoreEsquerda) que chama o m�todo de
novo e de cara imprime G. Como G � folha
volta na pilha de execu��o
para C que continua do
preOrdem(no.subarvoreDireita) que n�o tem nada
ent�o tamb�m volta-se na pilha de
execu��o para A que j� executou tudo
e assim finaliza a execu��o.
Assim a execu��o foi A B D F C G.
- Percursos em �rvores bin�rias � P�s-ordem
- O percurso p�s-ordem segue recursivamente os
seguintes passos para cada
sub�rvore da �rvore:
- Percorrer a sub�rvore esquerda em p�s-
ordem
- Percorrer a sub�rvore direita em p�s-
ordem
- Visitar a raiz
- Implementa��o em java:
public void posOrdem(ArvoreBinaria no) {
if (no != null) {

posOrdem(no.subarvoreEsquerda);

posOrdem(no.subarvoreDireita);
visitar(no);
}
}

Dada a �rvore abaixo:

/ |A| \
/ |B| \ / |C|
|D| |F| |G|

Percurso Em ordem:
Primeiramente dado o elemento A entramos
no m�todo e de imediato chama
posOrdem(no.subarvoreEsquerda) para A que
d� B e chamamos tamb�m o
m�todo posOrdem(no.subarvoreEsquerda)
para D. Como D n�o tem subarvore
esquerda nem direita ele vai para o
visitar(no) que imprime de fato D.
Ap�s isso, sobe na pilha de execu��o para
B e como j� executou o m�todo
posOrdem(no.subarvoreEsquerda) ele
executa posOrdem(no.subarvoreDireita)
em que passa F e chama novamente o m�todo
atual, como F � folha ele
vai acabar executanto visitar para F,
assim imprime F. Ap�s isso retira
o fluxo de F da pilha que j� executou,
volta para B que tamb�m j� executou
o seu fluxo e volta para A que parou no
posOrdem(no.subarvoreEsquerda),
assim agora A executa
posOrdem(no.subarvoreDireita) que passa C e executa
novamente o m�todo que por sua vez vai
chamar o m�todo
posOrdem(no.subarvoreEsquerda) passando
ent�o G. Novamente � chamado
o m�todo mas G � folha ent�o vai executar
visitar imprimindo de fato
o G na tela. Com isso volta na pilha de
execu��o para C que parou no
posOrdem(no.subarvoreEsquerda) e como ele
n�o tem nada na direita vai
executar visitar() que imprime seu valor
na tela. Como C terminou volta
na pilha de execu��o para A que executa o
visitar e por fim ele tb j�
executou tudo e assim termina o fluxo de
execu��o.
Assim a ordem de visita foi D F B G C A

- �rvores Bin�rias de Busca

- S�o estruturas adequadas � solu��o de problemas de busca. Elas
possuem as seguintes caracter�sticas:
- Dado um n� n da �rvore, qualquer outro n� n1 de sua
sub�rvore esquerda n�o possui chave
superior a chave de n.
- Dado um n� n da �rvore, qualquer outro n� n2 de sua
sub�rvore direita n�o tem chave inferior
a chave de n.
(Portanto, pega um n� da �rvore e a sua sub�rvore esquerda
N�O pode ter chave superior a desse
n� n, e a sua sub�rvore direita n�o pode ter chave inferior
a de n).
- Principais opera��es de uma �rvore bin�ria de busca
- Defini��o das principais opera��es.
interface IArvoreBuscaBinaria {
No busca(char id);
void inserir(No elemento);
No remove(char id); //remove um n� dessa �rvore
}
- �rvore Bin�ria de Busca � Opera��o busca
- Ao buscar um elemento x na �rvore, iniciamos a
busca pelo n� raiz.
- Caso n�o haja correspond�ncia com o q esta sendo
procurado, continuamos a busca pelo:
- Filho esquerdo, caso x < chave( raiz )
- Filho direito, caso x > chave( raiz )
- Esse procedimento ocorre recursivamente at� o n�
ser encontrado ou at� a constata��o
que a chave procurada n�o existe.
- A complexidade dessa opera��o � proporcional a
altura da �rvore. (Qto menor a altura
melhor ser� a complexidade da opera��o).
- Ex: Como encontrar o elemento G na �rvore a seguir?
/ |D| \
/ |B| \ / |F| \
 |A| |C| |E| |G|
Primeiramente � inspecionado o elemento D que �
raiz, ap�s isso verifica se
raiz � maior ou menor ao elemento inspecionado,
como ele n�o � D e � maior
que D descartamos a �rvore da esquerda e vamos
para a direita. Assim, F n�o
� o elemento procurado, F � maior ou menor ao
procurado, menor ent�o como ele
� inferior e os superiores est�o na direita ele
vai para a direita que l�
se encontra o G. Tudo que � maior ta na direita
e que � menor que o n� sendo
verificado est� na esquerda.
Tivemos apenas 3 compara��es, esse
comportamento � igual ao d� busca bin�ria
em que a metade dos elementos s�o descartados.
Esse tipo de �rvore � do tipo
cheia com altura MINIMA, por isso complexidade
O(n).
Se fosse uma �rvore ziguezague e ele estivesse
no �ltimo n� ter�amos muito mais
compara��es (7) - um por elemento, mesmo essa
�rvore possuindo o mesmo n�mero
de elementos. Por isso, qto maior altura menos
eficiente a opera��o.
- �rvore Bin�ria de Busca � Opera��o inser��o
- Primeiramente devemos identificar onde o elemento
deve ser inclu�do. Em seguida, basta
a inser��o do elemento.
- A disposi��o final da �rvore depende da ordem em
que os n�s forem inclu�dos.
- Como ficaria uma �rvore ap�s a inclus�o dos
elementos: A, B, C, D, E, F e G.
Primeiro A vai para raiz, depois verifica que B
vem depois de A, assim vai
para direita de A, depois temos que C � maior
que A e maior B, ent�o fica
� direita do elemento B, e assim por diante,
teremos assim a �rvore abaixo:
|A|
\
|B|
\
|C|
\
|D|
\
|E|
\
|F|
\
|G|
Essa seria uma �rvore horr�vel para opera��o de
busca.
- �rvore Bin�ria de Busca � Opera��o remo��o
- Para remover um elemento da �rvore bin�ria de busca
devemos considerar tr�s cen�rios:
- Elemento a ser removido n�o possui filho
 - Elemento a ser removido possui 1 filho
- Elemento a ser removido possui 2 filhos
- Elemento a ser removido n�o possui filho (como
remover um n� folha de uma �rvore)
- Nesse cen�rio basta remover o elemento
- Elemento a ser removido possui 1 filho
- Nesse cen�rio, o filho do n� a ser removido
passa a ser filho do pai do n� a
ser removido.
/ |F| \
/ |D| \ / |H| \
|B| |E| |G| |I|
/
|A|
Removendo o elemento B ter�amos:
/ |F| \
/ |D| \ / |H| \
|A| |E| |G| |I|
- Elemento a ser removido possui 2 filhos
- Nesse cen�rio o elemento pode ser substitu�do
pelo:
- Maior valor da sub�rvore esquerda.
- Menor valor da sub�rvore direita.
/ |F| \
/ |D| \ / |H| \
|B| |E| |G| |I|
/
|A|
Removendo o elemento D ter�amos:
/ |F| \
/ |B| \ / |H| \
|A| |E| |G| |I|
Tamb�m poderiamos ter escolhido o E, qualquer
um � poss�vel.

- Obs: O tipo de dados �rvore representa organiza��es hier�rquicas

entre dados. (CORRETO - Diferente das
estruturas lineares as arvores representa hierarquicamente os
dados).
- Obs: Quando n�o � poss�vel prever antecipadamente quantos n�s ser�o
necess�rios para a cria��o e utiliza��o
de uma �rvore bin�ria, utilizam-se, na sua implementa��o, listas
encadeadas. (CORRETA - � uma forma
de implementa��o sequencial de uma �rvore).
- Obs: Com rela��o a �rvores bin�rias � INCORRETO afirmar:
A) Uma �rvore bin�ria � uma cole��o finita de n>0 nodos que n�o
pode ser nula. (INCORRETA, podemos sim
ter uma �rvore vazia que � aquele que n�o possui elemento
algum.)
B) Uma �rvore bin�ria, cuja raiz armazena o elemento R, �
denominada �rvore de busca bin�ria se todo
elemento armazenado na sub�rvore esquerda � menor que R,
nenhum elemento armazenado na sub�rvore
direita � menor que R e as sub�rvores esquerda e direita
tamb�m s�o �rvores de busca bin�ria.
C) � um caso especial de �rvore em que nenhum nodo tem grau
superior a 2, isto �, nenhum nodo tem mais
que dois filhos. (qualquer n� pode ter 0, 1 ou 2 filhos.)
D) Existe um nodo especial denominado raiz e os demais nodos s�o
particionados em T1 e T2 estruturas
disjuntas de �rvores bin�rias. T1 � denominado sub�rvore
esquerda e T2 sub�rvore direita da raiz.
E) � uma �rvore que pode ser nula

- �rvores Balanceadas
- As �rvores balanceadas objetivam manter o custo de suas
opera��es em O (log n). (O(n) no pior caso)
- O custo das opera��es deve se manter durante toda manipula��o
da �rvore. (tanto para inserir qto remover)
- Para alcan�ar essa meta, a estrutura deve ser frequentemente
alterada de forma a se moldar aos novos
dados. (independente da ordem de inser��o dos elementos eles ir�o
se estruturar para n�o termos o
problema de formar aquela �rvore ziguezague como ocorreu antes).
- Uma estrutura que opera com essas caracter�sticas � denominada
balanceada.
- O conceito de balanceamento
- As �rvores completas minimizam o n�mero de compara��es
efetuadas no pior caso para uma busca.
(isso se deve pq essas �rvores completas tem altura m�nima
e como os elementos est�o bem
distribuidos teremos menos compara��es, diferente da
ziguezague que tem uma altura maior e
como consequencia mais compara��es)
- O objetivo � ter uma �rvore cuja altura seja da mesma
ordem de grandeza de uma �rvore completa
com o mesmo n�mero de n�s.
- Uma �rvore que satisfa�a essa condi��o � denominada
�rvore balanceada.
- �rvore AVL
- Uma �rvore bin�ria T � denominada AVL quando todos os
seus n�s est�o regulados. (mas como
saber se os seus n�s est�o regulados ou nao? abaixo a
resposta)
- O n� de uma �rvore bin�ria � considerado regulado quando
as alturas de suas sub�rvores esquerda
e direita diferem em at� uma unidade. Caso contr�rio,
consideramos que o n� esta desregulado.
- A diferen�a entre as duas sub�rvores de um mesmo n� �
chamado fator de balanceamento ou
simplesmente balan�o.
- Um n� regulado tem fator de balanceamento igual a: -1, 0
ou 1. (esses s�o os valores validos
para o balan�o de um n� que compoe uma �rvore balanceada.
Abaixo tem como calculamos esse fator
de balanceamento.)
- Calculando o fator de balanceamento de um n� v:
- balan�o( v ) = hSD ( v ) � hSE ( v ) (� a alguma da
subarvore de V menos a altura da
subarvore esquerda de V)
- Para aumentar o desempenho das opera��es realizadas sobre
a estrutura, o valor do fator de
balanceamento � pr�-calculado e mantido nos n�s
correspondentes. Esses valores s�o atualizados
durante a realiza��o das opera��es de inser��o e remo��o.
(ent�o esse c�lculo do balan�o �
calculado e armazenado em cada n�.)
- �rvore AVL � Principais opera��es
 - Defini��o das principais opera��es: (similar a
arvore binaria de busca)
interface IArvoreAVL {
No busca(char id);
void inserir(No elemento);
No remove(char id);
}
- As opera��es realizadas nas �rvores AVL seguem os
mesmos princ�pios das opera��es
realizadas nas �rvores bin�rias de busca, com as
seguintes varia��es: (toda mecanica
das arvores de busca se aplica nas arvores avl, mas
na avl temos a preocupa��o de deixar
os nos regulados a todo momento atraves das rota��es)
- Ap�s inserir ou remover um elemento na
�rvore, deve-se garantir que todos os
n�s da �rvore continuem regulados.
- Para garantir essa propriedade, rota��es s�o
executadas na estrutura.
- �rvores AVL - Rota��es
- Rota��es s�o transforma��es aplicadas na
estrutura da �rvore de forma a manter
a mesma regulada.
- Tipos de rota��es:
- Rota��o � direita
- Rota��o � esquerda
- Rota��o dupla � direita
- Rota��o dupla � esquerda
- �rvores AVL � Rota��o � direita
|C|
/
|B|
/
|A|
balan�o(c) = hSubarvoreDireita(C) -
h(SubarvoreEsquerda)
balan�o(c) = 1-3=-2 (n�o esta entre os
valores -1, 0 ou 1)
Podemos verificar que os demais n�s est�o
balanceados. Assim aplicaremos
a rota��o � direta para C.
/ |B| \
|A| |C|
A sub�rvore direta de B passou a ser a
subarvore esquerda de C.
- �rvores AVL � Rota��o � esquerda
- balan�o( c ) = hSD ( c ) � hSE ( c )
- balan�o( c ) = 3 � 1 = 2
|A|
\
|B|
\
|C|

Similar a anterior onde A n�o est�

balanceado. Teremos assim:
/ |B| \
|A| |C|
B passou a ser pai de A e a subarvore
esquerda de B passa a ser a
sub�rvore direita de A.
- �rvores AVL � Rota��o dupla � direita
- Temos que C abaixo est� desregulado.
/ |C|
|A|
\
|B|
balan�o( c ) = hSD ( c ) � hSE ( c )
balan�o( c ) = 1 � 3 = -2 (C n�o est�
balanceado)
Aqui podemos ver que o caminho � uma
esp�cie de curva e n�o um caminho
ret�lineo como antes. Isso caracteriza
uma rota��o dupla.
Assim, aplicando a rota��o a esquerda
temos ainda uma �rvore desbalanceada
para C, ela ficar� conforme abaixo:
|C|
/
|B|
/
|A|
A diferen�a � que ela ficou retilineo,
agora basta aplicar uma rota��o
simples a direita para termos ela
balanceda.
/ |B| \
|A| |C|
- �rvores AVL � Rota��o dupla � esquerda
|A|
\
|C|
/
|B|
Podemos notar que a �rvore est�
desbalanceada
balan�o( A ) = hSD ( A ) � hSE ( A )
balan�o( A ) = 3 � 1 = 2

O processo � similar ao anterior. Temos

uma curva entre os n�s,
assim precisamos de rota��o dupla.
Consideramos ent�o os n�s C e B
e fazemos uma rota��o simples � direta.
|A|
\
|B|
\
|C|
E agora fazemos uma rota��o � esquerda.
/ |B| \
|A| |C|
- Como ficaria uma �rvore AVL, inicialmente
vazia, ap�s a inser��o dos seguintes
elementos: 50, 55, 60, 70, 52 e 51. (Vale
lembrar que a AVL possui todos os seus
n�s balanceados, ou seja, a cada inser��o
devemos verificar que o balan�o est�
 igual a 0, -1 ou 1.)

O elemento 50 entra na �rvore que est� vazia.

O pr�ximo elemento � o 55 que � maior que 50,
assim fica � direita. A �rvore
continua balanceada.
Agora inserimos o 60 que � maior que 50 e maior
que 55, assim temos a �rvore:
|50|
\
|55|
\
|60|
Por�m, a �rvore ficou desbalanceada, pois 50
tem balan�o 2 visto que
balan�o( c ) = 2 � 0 = 2. Precisamos de uma
rota��o � esquerda (a �vore est�
puxando toda para direita, ent�o rotaciona ao
contr�rio). Assim:
/ |55| \
|50| |60|
Agora inclu�mos o valor 70 que � maior que 55 e
60 conforme abaixo:
/ |55| \
|50| |60|
\
|70|
Agora inclu�mos o elemento 52 que � menor que
55 e maior que 50, assim ficar�
na subarvore direita de 50 conforme abaixo:
/ |55| \
|50| |60|
\ \
|52| |70|
A �rvore continua balanceada. Agora 51 � menor
que raiz e maior que 50 ent�o
vai para direita e l� est� o 52, assim 51 �
menor que 52 ent�o vai para
esquerda de 52 ficando:
/ |55| \
|50| |60|
\ \
|52| |70|
/
|51|
Com a inser��o de 51 o n� 50 est� desregulado:
balan�o( 50 ) = hSD ( 50 ) � hSE ( 50 )
balan�o( 50 ) = 2 � 0 = 2
Como o caminho at� a folha � curva (uma curva
para direita) vamos aplicar uma
rota��o dupla a esquerda. Primeiramente fazemos
uma rota��o dupla a direita e
uma a esquerda.
/ |55| \
|51| |60|
/ \ \
|50| |52| |70|
- Uma estrutura de dados onde cada n� mant�m uma informa��o
adicional, chamada fator de balanceamento,
 que indica a diferen�a de altura entre as sub�rvores
esquerda e direita, � conhecida por �rvore:
A) hiberb�lica.
B) de busca bin�ria.
C) ordenada.
D) AVL. (CORRETA)
E) bin�ria.
- Na raiz de uma �rvore balanceada, o n�mero de descendentes da
esquerda e de descendentes da direita �
igual. (ERRADA, para uma �rvore estar balanceada ela pode
diferir em no m�ximo uma unidade, onde a
diferen�a de altura entre a subarvore direita e a subarvore
esquerda pode ser de 0 nesse caso iguais,
ou de - 1 em que a direta � uma unidade maior, ou 1 em que a
esquerda � maior em uma unidade.)
- Um programador decidiu utilizar, em determinado sistema de
an�lise estat�stica, uma �rvore AVL como
estrutura de dados. Considerando-se n a quantidade de elementos
dessa �rvore, o melhor algoritmo de
pesquisa, com base em compara��es, possui complexidade de tempo,
no pior caso, igual a:
A) O(1)
B) O(log n) (CORRETA)

- �rvore B
- A �rvore B � uma estrutura balanceada e largamente
utilizada como forma de armazenamento
secund�rio. Ela minimiza o tempo de acesso para
buscas, inser��es e remo��es. (�s
vezes o volume de dados � muito grande inviabilizando
de mante-la na mem�ria principal.
Por isso uma alternativa � a manipula��o dos dados na
mem�ria secund�ria que � mais
lenta, por isso a arvore B minimiza essas opera��es)
- Um n� de uma �rvore B � denominado p�gina.
- � poss�vel manter mais de uma chave em cada p�gina da
estrutura.
- Uma �rvore B de ordem d � uma �rvore ordenada que �
vazia, ou satisfaz as seguintes condi��es:
- Cada p�gina possui entre d e 2d chaves, exceto a
p�gina raiz que possui entre 1 e
2d chaves; (Podemos pegar como exemplo uma p�gina de
ordem 2, cada p�gina deveria ter
entre 2 e 4 chaves, exceto a raiz que teria um
intervalo de chaves variando entre 1 e 4.)
- Seja m o n�mero de chaves em uma p�gina P, ent�o:
- P tem m + 1 ponteiros para filhos;
- Se P for uma folha, todos os ponteiros
apontam para NULL.
- Se P n�o for uma folha, todos os ponteiros
referenciam uma p�gina.
(Assim, o numero de chaves de uma p�gina
determina a qtdade de filhos das
mesmas).
- Todas as folhas est�o no mesmo n�vel.
- Ex: 20 � a raiz e tem um filho na esq que � |3 10|
e um na direita que � |30 60|.
O |3 10| tem 3 filhos |1 2| |7 10| e |11 18
19|. Por fim, |30 60| tem mais tres
 filhos que s�o |21 25| |45 55| e |90 99|.
Cada ret�ngulo � uma p�gina da �rvore e cada
elemento dentro � uma chave. No
topo temos a p�gina raiz que � a chave 20. Na
base temos as folhas que est�o
todos no mesmo n�vel.
Como essa �rvore tem ordem 2 podemos afirmar
que a quantidade de chaves por p�gina
vai variar de 2 at� 4. A raiz pode ter de uma
at� 4 chaves nesse caso.
A quantidade de ponteiros para filhos �
determinada pela quantidade de chaves.
Logo, se a p�gina tem 1 elementos ela deve ter
2 ponteiros para filhos como a raiz.
Se a p�gina tem dois filhos ela ter� 3
ponteiros para filhos como nas p�ginas
descendentes diretos da raiz. As folhas apontam
para null.

/ |20| \
|3 10| |30
60|
/ \ \ \ \
\ \
|1 2| |7 8| |11 18 19| |21
25| |45 55| |90 99|
- Principais opera��es de uma �rvore B
- Defini��o das principais opera��es:
interface IArvoreB {
Elemento busca(int chave);
void inserir(Elemento elemento);
Elemento remove(int chave);
}
- �rvore B � Opera��o busca
- Passos para buscar um elemento em uma �rvore
B:
(A busca inicia pela p�gina raiz)
Passo 1: Busca-se o n� na p�gina corrente.
(binaria ou sequencial)
Passo 2: Caso o valor seja encontrado, a
opera��o � encerrada.
Passo 3: Caso contr�rio, identificamos a
pr�xima p�gina a ser pesquisada e
voltamos para o passo 1. (Como temos
v�rios filhos, esse passo sera
respons�vel por decidir quem ele deve
mandar para o passo 1)
Essa opera��o tem complexidade O( logd n), onde
d � a ordem da �rvore.
- Como localizar o elemento cuja chave � 18?

/ |20| \
|3 10| |30
60|
/ \ \ \ \
\ \
|1 2| |7 8| |11 18 19| |21
25| |45 55| |90 99|
 Iniciamos pela raiz e a primeira
compara��o � a chave 20 que � maior que
18, assim vamos para o ponteiro esquerdo
da chave 20.
Entao vamos a busca pela nova p�gina e
verificamos que 3 n�o � a chave
procurada, assim vamos para a chave 10
que tamb�m n�o � a procurada
e assim como o 3 tb � inferior ao
procurado, dessa forma vamos continua
a busca no ponteiro direito da chave 10.
Verificamos a p�gina das chaves
|11 18 19| e verificamos que 11 n�o � a
chave, mas 18 que � a pr�xima
p�gina verificada � o elemento que
estamos procurando. Assim, achamos.
- �rvore B � Opera��o inser��o
- Para inserir um elemento em uma �rvore B
devemos, inicialmente, identificar
onde o elemento deve ser inclu�do. A
opera��o busca auxilia nessa tarefa.
(Se o elemento n�o estiver na �rvore, a
opera��o busca indica a p�gina
e a posi��o que este elemento deve ser
inclu�do).
- A seguir inclu�mos o elemento na posi��o
apropriada.
- Se ap�s a inser��o uma p�gina ficar com 2d +
1 elementos, ent�o ser� necess�rio
realizar uma cis�o. (Vimos que cada
p�gina, fora a raiz, deve ter a
quantidade de chaves compreendida entre d
e 2d. Se ap�s a inclusao
tivermos uma quantidade superior, ou
seja, com 2d + 1 elementos devemos
tomar uma providencia para manter a
consistencia da estrutura).
- Como ficaria uma �rvore B (ordem 2) ap�s a
inclus�o dos seguintes elementos:
60, 90, 30, 55, 99, 45, 10, 29, 7, 3, 20, 18,
11, 25, 8, 2, 1 e 19?

Como foi informado que a �rvore tem ordem 2 o

n�mero m�ximo de elemento por
p�gina ser� de 4, a faixa vai de d a 2d e tem
ver se o limite m�ximo de paginas
n�o foi ultrapassadom, se foi temos que tomar
uma providencia.

Assim inicia a inclusao com 60 que fica na

p�gina raiz. Depois verificamos que 90
deve ficar a direita visto que � maior,
assim:
|60 90|
O elemento 0 � o menor da p�gina ent�o ele fica
na primeira posi��o da p�gina.
O 55 deve ficar entre o 30 e o 60, assim a
p�gina fica:
|30 55 60 90|
 O 99 � o maior, ent�o ele deve ser inserido no
fim da p�gina, mas isso excede o
tamanho da p�gina, assim devemos executar a
opera��o cis�o identificando o elem
central do conjunto que � o 60 que deve ir para
p�gina pai e vai referenciar
as duas p�ginas da cis�o. Ent�o basta
identificar o elemento central
|30 55 60 90 99|, elevar ele para p�gina pai, e
ele vai referenciar as duas
p�ginas resultantes, assim:
|60|
/ \
|30 55| |90 99|
O 45 � menor que 60 ent�o fica na esquerda e
como ele est� entre o 30 e o 55
ele ficar� no meio desses elementos. O 10 tb �
menor e deve ir para esquerda,
10 tb � menor que todos, ent�o fica na primeira
posi��o.
|60|
/ \
|10 30 45 55| |90 99|
Ap�s isso inserimos o 29 que estoura o tamanho
da p�gina 10 |29 30 45 55|
e assim fazemos uma nova cis�o atrav�s do
elemento central 30:
|30 60|
/ | \
|10 29| |45 55| |90 99|
Assim 30 foi para p�gina pai e referenciou as
duas resultante da cis�o.
Incluindo o elemento 7 ele vai para esquerda, o
3 tb ficando:
|30 60|
/ | \
|3 7 10 29| |45 55| |90 99|
O elemento 20 ficaria antes do 29 mas isso tb
estoura a p�gina, assim mais uma
cis�o � efetuada onde identifica-se o 10 como
elem central que vai para a pai:
|10 30 60|
/ / | \
|3 7| |20 29| |45 55| |90 99|
O elementos 18, 11 s�o inseridos normalmente e
o 25 novamente ocorre uma cis�o.
|10 30 60|
/ / | \
|3 7| |11 18 20 29| |45 55| |90 99|
Podemos verificar que com o 25 a p�gina fica |
11 18 20 25 29| e assim sendo o
elemento central agora � o 20 que vai para o
25.
|10 20 30 60|

|3 7| |11 18| |25 29| |45 55| |90

99|
Os elementos 8, 2 s�o inseridos normalmente,
mas o elemento 1 vai ocorrer um
 novo estouro de p�gina pois 1 |2 3 7 8|. O
central � o 3 que deve subir, mas
isso tb d� um estouro de p�gina na raiz. Mas
antes de pensar no pai fazemos
a cis�o atual ficando:
3 |10 20 30 60|

|1 2| |7 8| |11 18| |25 29| |45 55|

|90 99|
Mas como a pai excedeu temos uma nova cis�o
onde o central � 20 pois
3 |10 20 30 60|, assim temos:
|20|
|3 10| |30 60|

|1 2| |7 8| |11 18| |25 29| |45 55|

|90 99|
�ltimo nivel ficou intoc�vel, apenas criou-se
um pai acima e dividiu as outras
quatro chaves. Por fim o 19 ficar ap�s o 18.
|20|
|3 10| |30 60|

|1 2| |7 8| |11 18 19| |25 29| |45

55| |90 99|
- Mais algumas informa��es sobre essa
constru��o da �rvore:
- Uma cis�o transforma uma p�gina com
excesso de chaves em duas.
- A cis�o de p�ginas � propag�vel,
podendo atingir a raiz da �rvore.
- Uma inser��o pode alterar a altura da
�rvore.
- �rvore B � Opera��o remo��o
- Na remo��o devem ser considerados dois casos:
- Se o elemento a ser removido se
encontra na folha, � simplesmente
retirado.
- Caso contr�rio, ele � substitu�do pelo
valor imediatamente maior, que
se encontra em outra p�gina. (Assim, ele
� um n� interno que aponta
para filhos, nesse caso o valor maior na
p�gina filho assume)
- Se ap�s a remo��o alguma p�gina fica com
quantidade de chaves inferior a d, a
estrutura deve ser ajustada com uma das
seguintes t�cnicas:
- Concatena��o
- Redistribui��o
- Concatena��o
- Duas p�ginas adjacentes podem ser
concatenadas se a soma de suas
chaves for inferior a 2d.
- A chave pai, que fica entre os dois
ponteiros das p�ginas adjacentes,
passa a fazer parte dessa nova p�gina
concatenada.
- Esse procedimento pode se propagar,
podendo afetar a altura da �rvore.
- Ex: Como ficaria a �rvore abaixo (ordem
2) ap�s a remo��o do elemento 99?
|30 60|
/ | \
|10 29| |45 55| |90 99|
Como esta na folha basta remove-lo, mas a
qtade de chave � menor que
o permitido, pq a arvore � ordem 2
teriamos que ter duas chaves por
p�gina no minimo.
Aplicamos a concatena��o mesclando as
duas p�ginas e incluindo o elem
pai, ficando assim (60 � pai da |90 99|):
|30|
/ \
|10 29| |45 55 60 90|
- Redistribui��o
- No caso das duas p�ginas adjacentes
possu�rem em conjunto 2d ou mais
chaves essas podem ser equilibradamente
distribu�das:
- Concatena-se as duas p�ginas
(descendo inclusive as chaves entre
os ponteiros adjacentes).
- Em seguida efetua-se uma cis�o.
(nao tem alteracao estrutural
apenas movimento chaves de uma
pagina para outra)
- Esse procedimento n�o pode se
propagar. A p�gina pai �
modificada, mas seu n�mero de
chaves permanece o mesmo.
- Como ficaria a �rvore abaixo (ordem 2)
ap�s a remo��o do elemento 99?
|30 60|
/ | \
|10 29| |45 55 58| |90 99|
Como 99 � folha basta remove-lo, mas a pg
est� inconsistente com qtde
de elemento inferior a 2 que � o minimo
para cada pagina.
Mesclamos os elementos das duas paginas,
incluindo o pai ficando:
|30|
/ \
|10 29| |45 55 58 60| 90
Como a p�gina ficou com excesso estourou
a p�gina, assim fazemos
a cis�o onde o elemento central vai para
o pai. Assim:
|30 58|
/ \
|10 29| |45 55 60 90|
- �rvore B � Defini��es de outros autores (Diferen�as de
algumas propriedades na literatura)
- Dada uma �rvore B com grau m�nimo igual a t:
- Toda p�gina diferente da raiz deve ter pelo
menos t filhos.
 - Uma p�gina pode ter no m�ximo 2t filhos.
- Como consequ�ncia:
- Cada p�gina teria uma quantidade m�nima de
chaves igual a t - 1;
- Todo n� pode ter no m�ximo 2t � 1 chaves.

- Obs: Uma �rvore B � um tipo de �rvore que se mant�m

balanceada com o decorrer do tempo. Para
tanto, ela usa uma s�rie de opera��es que garantem a
manuten��o de uma s�rie de
propriedades importantes, uma das quais � a ordem da
�rvore que pode ser definida como
o n�mero m�ximo de elementos que podem ser
armazenados em um n� da �rvore. Com base
nesses conceitos, qual das situa��es a seguir
representa uma propriedade das �rvores B?
(O enunciado adotou a postura que a ordem define o
numero m�ximo de chaves de uma pg)
A) Em uma �rvore B de ordem maior do que 1, n�o
� permitido que uma folha
armazene apenas um elemento. (Imagine uma
�rvore com uma raiz com
um elemento. Ela seria tb uma folha, isso
contraria o enunciado, assim
a afirmativa est� EERADA.)
B) Em uma �rvore B de ordem d, a raiz armazena
um n�mero de elementos n tal que
d<=n<=2d. (A raiz pode ter um elemento,
ent�o ERRADA).
C) Em uma �rvore B de ordem d, pode haver
folhas em alturas diferentes da �rvore
at� que tenham sido inseridos, pelo
menos, 2d+1 elementos. (As folhas
estao sempre no mesmo nivel, ERRADA.)
D) Em um n� de uma �rvore B que contenha n
elementos n�o vazios, podem-se ter, no
m�ximo, n/2 ponteiros apontando para
vazio (nil ou null). (A qtdade de
filhos de uma p�gina � definido pela
qtdade de chaves + 1, ERRADA)
E) Em um n� interno de uma �rvore B que
contenha n elementos, t�m-se
exatamente n+1 ponteiros que n�o apontam
para vazio (nil ou null).
(Se a pg for interna os ponteiros
referenciam uma pg da estrutura,
sen�o, se for folha, apontam para null.
CERTA.)
- Obs: Considere uma �rvore B de ordem 2 inicialmente
vazia.
Os n�meros abaixo s�o inseridos na seguinte ordem:
10, 15, 8, 3, 4, 12, 20, 9.
Que n�mero(s) comp�e(m) o n� raiz?
A) 8
B) 10
C) 4 e 15
D) 8 e 12 (CORRETA)
E) 9 e 10
Se � ordem 2, todas paginas ter�o de 2 a 4 elemento
fora a raiz.
Inserimos os elementos 10, 15 a direita de 10, 8 que
� menor que todos e 3 que agora
� o menor, ficando: |3 8 10 15|
Ao inserir o elemento 4 temos um estouro da p�gina 3
|4 8 10 15|, assim faz a cis�o.
|8|
|3 4| |10 15|
Os elementos 12 e 20 entram normalmente na pg da
direita. Por fim o elemento 9 tb
� maior que 8, mas temos um estouro 9 |10 12 15 20|
assim o central vai para o pai e
quebra em dois a pagina em que o 12 tem 9 e 10 na esq
e 15 e 20 na dir referenciando as
duas paginas:
|8 12|
|3 4| |9 10| |15 20|
Assim o correto � 8 e 12 letra D.

- Tabela Hash (ou Tabela de Dispers�o ou Tabela de Espalhamento)

- Conceitos gerais
- A tabela hash � uma estrutura de dados eficaz para implementar
dicion�rios. (Discion�rios s�o similares
a um mapa onde elementos ser localizados rapidamente pela sua
chave. Os elementos s�o armazenados em
pares de chave valor onde os valores sao acessados pelas suas
chaves correpondentes.)
- Um elemento � armazenado em uma posi��o indicada por h( k ). A
fun��o hash h calcula a posi��o onde o
elemento ser� armazenado dentro da tabela hash. (Essa fun��o
hash recebe como parametro a chave de um
elemento e retorna a posi��o dentro da tabela hash onde esse
elemento deve estar).
- Fun��o hash
- Mapeia o universo de chaves para as posi��es de uma tabela
hash. (Quem determina onde o elemento
se posicionara dentro da tabela hash � a fun��o hash)
- Bucket � o nome dado ao lugar onde os elementos s�o armazenados
na tabela hash. (A tabela hash �
constituida de um arranjo de beckets e assim a funcao hash � que
� a grande respons�vel por identificar
em que bucket um determinado elemento deve ser armazenado.
- A fun��o hash reduz a faixa de �ndices poss�veis e,
consequentemente, o tamanho da tabela hash.
(a ideia da fun��o hash � mapear um elemento para um bucket, mas
podemos ter mais de um elemento
mapeado para o bucket e essa situacao � a colisao e isso que faz
com que se reduza a faixa de indices
possiveis).
- Uma fun��o hash pode mapear duas chaves distintas para uma
mesma posi��o da tabela. Essa situa��o �
chamada de colis�o.
- Ex: Um conjunto de elemento poss�veis k1, k2, k3, etc, seria
mapeados para a tabela hash.

k1, k2, k3, k4, k5

(arranjo de buckets) T (tabela Hash T)
_______________
|_______________|
 |_______________|
|_______________| h(k1)
|_______________| h(k4)
|_______________|
|_______________| h(k2) h(k5) -
esses dois estao no mesmo bucket
|_______________| da tabela
hash
|_______________| h(k3)
|_______________|
|_______________|

h(k) = k mod 10 - onde k � a chave do elemento a ser

manipulado. Essa funcao retorna o hash
da divis�o da chave do elemento que estamos
manipulando por 10.

Assim, dados os elementos 12, 3, 55, 5, 17, vamos calcular

o hash de cada um:
h( 12 ) = 12 mod 10 = 2 - 12/10 � 1 e resta 2
h( 3 ) = 3 mod 10 = 3 - 3/10 n�o d�, poe 0, no resulta e um
zero ap�s o 3, assim repetiu o 3 q
h( 55 ) = 5 mod 10 = 5 � o resto e
colocou o 0 dando 30/10
h( 5 ) = 5 mod 10 = 5
h( 17 ) = 17 mod 10 = 7
_______________
|______________0|
|______________1|
|______________2| h(12)
|______________3| h(3)
|______________4|
|______________5| h(55) h(5)
|______________6|
|______________7| h(17)
|______________8|
|______________9|
- Uma fun��o hash h deve ser determin�stica, no sentido de que
uma dada entrada k sempre deve produzir a
mesma sa�da h ( k ). (Sempre vai para o mesmo bucket)
- Alguns tipos comuns de fun��es hash:
- M�todo da divis�o
- M�todo da multiplica��o
- Fun��o hash � M�todo da divis�o (Visto no exemplo acima)
- O m�todo de divis�o mapeia uma chave k para uma das m
posi��es da tabela hash, tomando o resto
da divis�o de k por m: H(k) = k mod m
- Onde:
- k � representa a chave do elemento manipulado.
- m � indica o tamanho do arranjo de buckets.
- Fun��o hash � M�todo de multiplica��o
- Esse m�todo funciona em duas etapas:
- Multiplicamos a chave k por uma constante A na
faixa 0 < A < 1 e extra�mos a parte
fracionaria de kA. (Constante na faixa maior que 0 e
menor que 1)
- Em seguida, multiplicamos esse valor por m e
tomamos o piso do resultado.
H(k) = |m (kA mod 1)|
 --------
Parte fracion�ria (kA mod 1) onde multiplica k
por A e depois por m.
- Onde:
- k � representa a chave do elemento
manipulado.
- m � indica o tamanho do arranjo de buckets.
- T�cnica de resolu��o de colis�o: Encadeamento Separado (Ou hash
aberto)
- Essa � a t�cnica mais simples onde todos os elementos
resultantes do hash v�o para a mesma posi��o em
uma lista encadeada. (Cada bucket � uma lista encadeada)
- Cada entrada da tabela hash cont�m um ponteiro para o inicio de
uma lista encadeada ou tem valor NULL.
(A tabela hash pode ser representada por um vetor onde cada
posi��o do vetor aponta para uma lista
encadeada que � o bucket, se n�o tiver nenhum elemento o valor
seria null)
- Outras estruturas de dados podem ser usadas no lugar da lista
encadeada. (Por ex. arvores)
_______________
|_____null_____0|
|______________1| -> | |k1 | -> | |
k2| |
|_____null_____2|
|_____null_____3|
|_____null_____4|
- T�cnica de resolu��o de colis�o: Endere�amento Aberto (Ou Hash
Fechado)
- Nessa t�cnica, todos o elementos ficam na pr�pria tabela hash.
(N�o existe nnehuma lista e nenhum
elemento fica armazenado fora da tabela hash)
- Cada entrada da tabela hash cont�m um elemento do conjunto
din�mico ou NULL.
- A vantagem do endere�amento aberto � que ele evita por completo
os ponteiros, consumindo menos mem�ria.
- Em vez de seguir ponteiros, calculamos a sequencia de posi��es
a examinar. (tem algumas t�cnicas para
calcular isso mas nao s�o cobradas)
_______________
|______79______0|-- do 79 aponta
para o 98 no indice 3
|_____null_____1| |
|______69______2| |
|______98______3|<- | o 98 aponta
para o 14 no indice 6
|_____null_____4| |
|_____null_____5| |
|
______14______6|<--|
Todos elementos estao na hash sem nenhuma outra estrutura.
- Fun��o hash - Colis�o
- A fun��o hash menos eficiente seria aquela que mapeia todos os
elementos para um mesmo bucket. (Se todos
os elementos foram para o mesmo bucket teremos uma enorme
lista encadeada, e a complexidade
de busca numa lista encadeada � O(n) - o pior caso para uma
tabela hash).
- A fun��o hash mais eficiente seria aquela que distribui de
maneira mais uniforme poss�vel os elementos
na tabela de espalhamento.
- Para ter uma fun��o hash eficiente � necess�rio o conhecimento
da natureza das chaves manipuladas.
- Principais opera��es de uma tabela hash
public interface ITabelaHash {
void inserir(TabelaHash tabHash, Elemento elemento);
Elemento buscar(TabelaHash tabHash, Chave chave); //busca
um elemento na tabela
Elemento remover(TabelaHash tabHash, Elemento elemento);
}

- Opera��o Inser��o
- Passos a serem executados:
1� passo: Computar a fun��o hash a partir da chave do
elemento. (Identifica o bucket
onde o elemento deve ser inserido)
2� passo: Inclui elemento na lista encadeada. (Na
lista que representa o bucket)
- Opera��o Busca
- Passos a serem executados:
1� passo: Computar a fun��o hash a partir da chave do
elemento. (Identifica o bucket)
2� passo: Busca elemento na lista encadeada.
- Opera��o Remo��o
- Passos a serem executados:
1� passo: Computar a fun��o hash a partir da chave do
elemento. (Identifica o bucket)
2� passo: Busca elemento na lista encadeada.
(Identifica o elemento dentro do bucket)
3� passo: Remove o elemento da lista encadeada.
- Obs: Com rela��o a m�todos de pesquisa de dados, julgue os itens
subsecutivos. Listas encadeadas n�o s�o
utilizadas na busca que emprega tabelas hash. (ERRADA, eles
implementam os buckets das tab hash)
- Obs: A busca que utiliza uma tabela hash realiza compara��o das
chaves para encontrar a posi��o do elemento que
est� sendo buscado. (Para identifica o bucket basta computar a
fun��o hash e n�o ficar comparando
elementos).
- Obs: As colis�es ocorrem na utiliza��o de tabela hash porque v�rias
chaves podem resultar na mesma posi��o.
(CORRETA)
- Obs: No uso de estruturas de transforma��o de chave (hashing), a
solu��o de colis�es usando encadeamento tem
como principal caracter�stica o fato de nunca transbordar.
Adicionalmente, o tempo de busca na lista
ligada pode ser reduzido se uma lista duplamente encadeada for
utilizada. (INCORRETA, as listas encadeadas
e duplamente encadeadas tem a mesma complexidade temporal nas
buscas.)