Você está na página 1de 52

Estruturas Avanadas de

Dados II
(Heap)
Professor Gilberto Iraj Mller e Patrcia Jaques

ltima atualizao 06/09/2012

Lembrando o que uma Fila de


Prioridade
Uma fila de prioridade

armazena uma coleo de


entradas (entrada)
Cada entry um par
(key, value)
Principais mtodos:
insert(k, x)

insere uma entrada de


chave k e valor X
removeMin()
reremove e retorna a
entrada com menor chave

Mtodos adicionais
min()

retorna sem remover a


chave de menor valor
size(), isEmpty()

Aplicaes:

Fila de espera em avio


Leiles
Mercado de aes

Lembrano de fila de
prioridade
Podemos usar uma fila de

prioridade para ordenar


um conjunto de elementos

Insere os elementos com


uma srie de operaes
insert
Remove os elementos em
ordem com uma srie de
operaes removeMin

O tempo de execuo

depende da implementao
de fila de prioridade:
Sequencia ordenada:
O(n2) time
Sequencia no-ordenada:
O(n2) time

Podemos fazer melhor?

Algorithm PQ-Sort(S, C)
Input sequence S, comparator C
for the elements of S
Output sequence S sorted in
increasing order according to C
P priority queue with
comparator C
while S.isEmpty ()
e S.remove (S. first ())
P.insertItem(e, e)
while P.isEmpty()
e P.removeMin()
S.insertLast(e)
3

rvore Binria
uma rvore onde cada n pode conter
nenhum, 1 ou 2 filhos apenas
Grau=2.

Uma rvore binria formada por ns onde


cada n contm um valor, um ponteiro
esquerdo e um ponteiro direito.
A
B

rvore Binria
O n A a raiz da rvore. Como B a raiz da sua

sub-rvore esquerda dizemos que B o filho


esquerdo de A, do mesmo modo, C o filho
direito de A. Por isso A o pai dos ns B e C e estes
dois so irmos.
A

filho esquerdo de A

filho direito de A

G
5

Tipos de rvores Binrias: Estritamente Binria

Ocorre quando todo n que

no folha tiver sub-arvores


esquerda e direita no
vazias.
todo n tem 0 ou 2 filhos.

Estritamente
Binria

Nmero de ns em uma rvore


estritamente binria com n
folhas:
2n-1

bibliografia:Szwarcfiter, J. & Markenzon,


Lilian. Estrturas de Dados e seus
Algoritmos. Rio de Janeiro: LTC, 1994

Tipos de rvores Binrias:


Binria Completa
uma rvore

estritamente binria
onde todos os ns folhas
se encontram ou no
ltimo ou no penltimo
nvel da rvore.

Binria
Completa
bibliografia:Szwarcfiter, J. & Markenzon,
Lilian. Estrturas de Dados e seus
Algoritmos. Rio de Janeiro: LTC, 1994

Tipos de rvores Binrias:


Binria Cheia
bibliografia:Szwarcfiter, J. & Markenzon,
Lilian. Estrturas de Dados e seus
Algoritmos. Rio de Janeiro: LTC, 1994

Binria
Cheia

rvore estritamente binria onde os ns folhas se encontram no ltimo

nvel.
O nmero total de ns em (tn) em uma rvore binria cheia de altura h :
tn=2h-1
Assim, pela mesma frmula podemos afirmar que, numa rvore binria
completa, a altura h de uma rvore dada por:
h= log2(tn+1)
Embora a rvore binria completa possua muitos ns, a distncia da raiz
at qualquer folha (profundidade) relativamente pequena.
8

O que Heap?
uma Estrutura de prioridades,
forma de rvore binria completa,
representa uma ordem parcial entre
elementos do conjunto;

na
que
os

A rvore est completamente preenchida em


todos os nveis exceto talvez o mais baixo;

Nvel mais baixo preenchido a partir da


esquerda;

Estrutura de um Heap

Com o ltimo nvel,


uma rvore binria completa
Ignorando o ltimo nvel,
o heap uma rvore binria cheia

10

Tipos de Heap
Dois tipos de heap (propriedades):
Mximo
Mnimo

Heap Mximo

Heap Mnimo
11

Heap Mximo
Para todo n diferente da raiz,

o pai maior ou igual aos filhos:


A[i]>=FILHO_ESQ(I)
A[i]>=FILHO_DIR(I)

O maior elemento de um heap mximo est


armazenado na raiz;

Uso do Heap Mximo em algoritmos de


classificao como o HeapSort.

12

Heap Mnimo
Para todo n diferente da raiz,

o pai menor ou igual aos filhos:


A[i]<=FILHO_ESQ(I)
A[i]<=FILHO_DIR(I)

O menor elemento de um heap mnimo est


armazenado na raiz;
Uso do heap mnimo em filas de
prioridades.

13

Altura de um Heap
Theorem: um heap que armazena n chaves tem altura
O(log n)

n = tn

O nmero total de ns em (tn) em uma rvore binria cheia de altura h


:
tn=2h-1
Assim, pela mesma frmula podemos afirmar que, numa rvore binria
completa, a altura h de uma rvore dada por:
h= log2(tn+1)

14

Insero

Exemplo: insero da chave 15


2a

1)Coloca o novo n no ltimo


nvel na posio mais a
esquerda possvel
Satisfaz condio de rvore
binria completa, mas no
a condio de heap

2) Tenta ordenar do novo n


para a raiz
Chamado de up-heap bubbling
ou heapfy
2b

15

Insero - complexidade
2a
1

1)Coloca o novo n no ltimo


nvel na posio mais a
esquerda possvel
Satisfaz condio de rvore
binria completa, mas no
a condio de heap

2) Tenta ordenar do novo n


para a raiz

2b

Passo 1= O(1)
Tn=O(log n)

Passo 2= log n

16

Exerccio (1)
Insira a entrada (2,T) na rvore abaixo.
A chave 2. Mostre os passos da
resoluo.

17

Remoo
(raiz)

2a
8

1)Em um heap mximo, maior


chave encontra-se na raiz
Tn=O(1)

2) Substitui raiz pelo ltimo n


11

2b

No heap mximo,
se tem dois filhos, testa ordem com o filho de maior chave
No heap mnimo
testa ordem com o filho de menor chave

3) Heapfy
Tn=O(log n)
18

Exerccio (2)
Faa a implementao do mtodo de
remoo do heap abaixo.

19

Resumo das Complexidades

Mtodo

Tempo

size

O(1)

isEmpty

O(1)

min

O(1)

insert

O(log n)

removeMin

O (log n)

20

Representao
Um Heap pode ser representado por um array
unidimensional.

16

RAIZ = 0.

14

10

PAI(i) = (i-1)/2
8

FILHO_ESQUERDO(i) =
return i*2 + 1
2

FILHO_DIREITO(i) =
return i*2 + 2

16 14 10 8

2 4

821 9

Classe Node
class Node {
private int iData; // data item (key)
// ------------------------------------------------------------public Node(int key) // constructor
{
iData = key;
}
// ------------------------------------------------------------public int getKey() {
return iData;
}
// ------------------------------------------------------------public void setKey(int id) {
iData = id;
}
// ------------------------------------------------------------} // end class Node

22

Heap (1)
class Heap {
private Node[] heapArray;
private int maxSize; // size of array
private int currentSize; // number of nodes in array
public Heap(int mx) // constructor
{
maxSize = mx;
currentSize = 0;
heapArray = new Node[maxSize]; // create array
}
public boolean isEmpty() {
return currentSize == 0;
}

23

Heap (2)
public boolean insert(int key) {
if (currentSize == maxSize)
return false;
Node newNode = new Node(key);
heapArray[currentSize] = newNode;
heapfyUp(currentSize++);
return true;
} // end insert()

82

70

51

63

55

37

10

43

27

30

34

95

10

11

12

13

14

15

16

17

24

82

51

37

95

Temp

C
1

Heap (3)
public void heapfyUp (int index) {
int parent = (index - 1) / 2;
Node temp= heapArray[index];
while (index > 0
&& heapArray[parent].getKey() < temp.getKey()) {
heapArray[index] = heapArray[parent]; // move it down
index = parent;
parent = (parent - 1) / 2;
} // end while
heapArray[index] = temp;
} // end trickleUp()

82

70

51

63

55

37

10

43

27

30

34

95

10

11

12

13

14

15

16
26

17

Heap (4)
public Node remove() // delete item with max key
{ // (assumes non-empty list)
Node root = heapArray[0];
heapArray[0] = heapArray[--currentSize];
heapfyDown(0);
return root;
} // end remove()

27

Heap (5)
public void heapfyDown(int index) {
int largerChild;
Node top = heapArray[index]; // save root
while (index < currentSize / 2) // while node has at least one child
{
int leftChild = 2 * index + 1;
int rightChild = leftChild + 1;
// find larger child
if (rightChild < currentSize && // (rightChild exists?)
heapArray[leftChild].getKey() < heapArray[rightChild].getKey())
largerChild = rightChild;
else
largerChild = leftChild;
// top >= largerChild?
if (top.getKey() >= heapArray[largerChild].getKey())
break;
// shift child up
heapArray[index] = heapArray[largerChild];
index = largerChild; // go down
} // end while
heapArray[index] = top; // root to index
} // end trickleDown()

28

Heap (6)
public boolean change(int index, int newValue) {
if (index < 0 || index >= currentSize)
return false;
int oldValue = heapArray[index].getKey(); // remember old
heapArray[index].setKey(newValue); // change to new
if (oldValue < newValue) // if raised,
heapfyUp(index); // trickle it up
else
// if lowered,
heapfyDown(index); // trickle it down
return true;
} // end change()

29

Lembrando de fila de prioridade


Podemos usar uma fila
de prioridade para
ordenar um conjunto
de elementos

Insere os elementos com


uma srie de operaes
insert
Remove os elementos em
ordem com uma srie de
operaes removeMin

O tempo de execuo

depende da
implementao de fila
de prioridade:
Com Listas: O(n2)

Com Heap: O(nlog(n))

Inserir todos os elementos:

O(nlog(n))
Remover todos os elementos:
O(nlog(n))

Algorithm PQ-Sort(S, C)
Input sequence S, comparator C
for the elements of S
Output sequence S sorted in
increasing order according to C
P priority queue with
comparator C
while S.isEmpty ()
e S.remove (S. first ())
P.insertItem(e, e)
while P.isEmpty()
e P.removeMin()
S.insertLast(e)

O(nlog(n)) muito melhor que O(n2)

30

Representao
Um Heap pode ser representado por um array
unidimensional.

16

RAIZ = 0.

14

10

PAI(i) = (i-1)/2
8

FILHO_ESQUERDO(i) =
return i*2 + 1
2

FILHO_DIREITO(i) =
return i*2 + 2

16 14 10 8

2 4

831 9

Procedimentos sobre Heaps


Heapify
Garante a manuteno da propriedade de
ordem do Heap. Complexidade O(logn).

Build-Heap
Produz um heap a partir de um vetor no
ordenado. Complexidade O(n).

Heapsort
Procedimento de ordenao.
Complexidade(nlogn).

32

maxHeapfy(A, 0, A.length)

Max-heapfy

public static void maxHeapfy (int a[], int i, int N) {


int maior=i;
int l = 2*i+1; // posicao do filho esquerdo de i
int r = 2*i+2; // posicao do filho direito de i
if (l < N && a[l]>a[i]) maior=l;
if (r < N && a[r]>a[maior]) maior = r;
if (maior!=i) {
int T = a[i];
a[i] = a[maior];
a[maior] = T;
maxHeapfy (a, maior, N);
}
}
25

25
12
09

18

22
18

10

13

09

22
12

10

13
33

Exerccio 3
Usando o slide anterior como modelo,
ilustre a operao de

MAX-HEAPFY(A,2, A.length)
sobre o arranjo
A={27,17,3,16,13,10,1,5,7,12,4,8,9,0}

34

HeapSort
Algoritmo de ordenao sofisticado;
Desenvolvido em 1964 por Robert W. Floyd (New
York, USA) e J.W.J. Williams;

Consiste em um mtodo de seleo em rvore

binria do tipo heap, de forma ordenada em relao


aos valores de suas chaves;

Consiste em duas fases:


Fase 1: construo do heap (build-Heap)
Fase 2: seleo dos elementos na ordem desejada (Heapsort)

35

HeapSort
Fase 1: construindo o heap
a partir da estrutura de dados vista anteriormente, o passo
seguinte consiste em trocar as chaves de posio no vetor,
de forma que a rvore representada passe a ser um heap,
ou seja, toda raiz de cada sub-rvore satisfaa as seguintes
condies:

A[Pai(i)] >= A[i]

os testes das chaves iniciam pela ltima subrvore


prosseguindo, a partir da, para as subrvores que
antecedem esta, at testar a raiz da rvore.
rvore representada pelo vetor C1..7

36

HeapSort
Exemplo de construo do

12

heap:
09

Seja o seguinte vetor de

13

chaves:

12 09

13 25

18 10

22

25

18

10

22

37

HeapSort
12

Transformao da subrvore de
raiz 13 em heap
09
12 09

22 25

18 10

13
25

22 09

18 10

18

10

13

12

Transformao da subrvore de
raiz 09 em heap
12 25

22

25

22

13
09

18

10

13

38

HeapSort
25

Transformao da subrvore de
raiz 12 em heap
12
25 12

22 09

18 10

13
09

Rearranjo de uma subrvore do


nivel inferior. Agora, a rvore toda
um heap!
25 18

22 09

12 10

22
18

10

13

25
18

22

13
09

12

10
39

13

39

HeapSort
Fase 2: seleo dos
elementos na ordem
desejada

25 18

22 09

12 10

13

13 18

22 09

12 10

25

se a chave que est na raiz a


maior de todas, ento sua
posio definitiva correta, na
ordem crescente, na ltima
posio no vetor;
ento, esta maior chave
colocada na ltima posio do
vetor, por troca, com a chave
que ocupa aquela posio.

13

18

09

22

12

10
40

HeapSort
Seleo da segunda maior chave:

22

18

Colocao da segunda maior chave


em sua posio:

10 18 13 09

13

12 22

25

10
09

12

10
18

(A rvore novamente rearranjada


p/ formar um heap)

22 18 13 09

12 10

25

09

13

12
41

HeapSort
Seleo da terceira maior chave:

Seleo da terceira maior chave:

18

18

10

09

12

13

09

12
(A rvore novamente rearranjada
p/ formar um heap)

18 10 13 09

12 22

25

13

10
(A rvore novamente rearranjada
p/ formar um heap)

18 12 13 09

10 22

25
42

HeapSort
Colocao da terceira maior chave
em sua posio:

Seleo da quarta maior chave:

13
10 12

13 09 18 22

25
12

10

12

13

10

09
13 12

10 09 18 22

09
43

25

HeapSort
Colocao da quarta maior chave
em sua posio:

Seleo da quinta maior chave


em sua posio:

12
9 12

10 13 18 22

25
9

12

10

12

10

10 13 18 22

25

44

HeapSort
Colocao da quinta maior chave
em sua posio:

9 10

12 13 18 22

25

Final do processo de classificao:

09 10

12 13 18 22

25

10
10
09
09

45

HeapSort

Tanto no melhor como no pior caso, o


desempenho do HeapSort igual a
O(nlog2n).

46

Exerccios
4.1 Considerando o seguinte vetor:
11

12

17

10

a) Construa o heap
b) Aplique o heapSort

47

// Algoritmo do livro do Cormen


public static void heapSort(int a[]) {
// construo do heap
for (int k = a.length/2-1; k >= 0; k--) {
maxHeapfy (a, k, a.length);
}
// troca de lugar
for (int N=a.length-1; N>=1; N--) {
// o 1 elemento
int T = a[0];
// com o ltimo
a[0] = a[N];
a[N] = T;
maxHeapfy (a, 0, N); // torna o vetor uma rvore heap
}
}

48

public static void maxHeapfy (int a[], int i, int N) {


int maior=i;
int l = 2*i+1; // posicao do filho esquerdo de i
int r = 2*i+2; // posicao do filho direito de i
if (l < N && a[l]>a[i]) maior=l;
if (r < N && a[r]>a[maior]) maior = r;
if (maior!=i) {
int T = a[i];
a[i] = a[maior];
a[maior] = T;
maxHeapfy (a, maior, N);
}
}

25

12

09

22
18

10

13
49

Exerccio (4)
Ilustre a operao de HEAPSORT sobre
o arranjo A={5,13,2,25,7,17,20,8,4}.

Exerccio (5)
Ilustre a operao de HEAPSORT sobre
o arranjo A=
{2,5,16,4,10,23,39,18,26,15}.

51

Bibliografia

Silberchatz, A; Korth, H. F., Sudarshan, S. Sistema de


Banco de Dados. 3. Edio, Makron Books, 1999.

Lafore, Robert. Estruturas de Dados & Algoritmos em


Java. Editora Cincia Moderna, 2004.

Lminas do Prof. Alexandre Parra Carneiro da Silva.


Mtodos de Classificao por Seleo: HeapSort.

52