Introduo

Funes

Algoritmo HeapSort

Estudo de Caso

do
HeapSort

 Algoritmo de ordenao sofisticado Desenvolvido em 1964 por Robert W. Floyd (New York, USA) e J.W.J. Williams O(nlgn) no pior caso In-place: a ordenao que efetuada com a prpria sequncia sem utilizar sequncias adicionais. Tcnica de Projeto de Algoritmos: Utilizao de uma estrutura de dados (heap) para gerenciar informaes durante a execuo do algoritmo

 Constroi_Heap (Build-heap ou BUILD-MAX-HEAP) produz um heap a partir de um array de entrada no ordenado. Heapify (ou MAX-HEAPIFY) chave para manter a propriedade do heap mximo. Heapsort ordena o array localmente.

 Um Heap pode ser representado por um array unidimensional de modo que A raiz ocupa a posio 1. Os demais elementos obedecem:

Exemplo:
16 1 14 2 10 3 7 5 4 9 1 9 6 3 7

esq.i = 2i dir.i = 2i + 1
8 2

8 4

10

16 14
1 2

10
3

8
4

7
5

9
6

3
7

2
8

4
9

1
10

 Heap Mximo

Para todo n diferente da raiz, o pai

maior ou igual que ambos os

filhos.

A[i]>=A[2i] A[i]>=A[2i+1]

O maior elemento de um heap mximo est armazenado na raiz.

 Construo Bottom-up Das folhas para a raiz Da direita para a esquerda no array Top-down Da raiz para as folhas Da esquerda para a direita no array

 Construo bottom-up de um heap mximo Caso base: n=1 (no h o que fazer)

14

14

 Para n>1 Ajuste da ordem parcial para o novo elemento

1 2 14
14 2 1

14

14

Algoritmo Constri-Heap: Para i n/2 at 1 faa Heapify (A, n, i ) Onde:

A o array contendo os elementos n o nmero de elementos no array, e i o ndice do n raiz da sub-rvore

considerada.

 Rearranja o heap aps a retirada da raiz

Toma dois (sub)heaps mais um novo elemento e constri um novo heap contendo todos.

Algoritmo Heapify(A, n, i )

Enquanto 2i n faa /* i tem filhos*/ { Se 2i < n ento /* i tem dois filhos*/ Se A[2i ] > A[2i +1] ento maior 2i seno maior 2i +1 seno maior 2i /* o nico o maior*/ Se A[i ] < A[maior] ento {A[i ] A[maior]; i maior } seno i n /* deixe o lao*/ }

Aps construir o heap, o array visto como contendo: um heap + parte da soluo

Algoritmo Heapsort (A, n) Constri-Heap(A, n) Para j n at 2 faa { exchange (A[1], A[ j]); Heapify (A, j-1, 1) }

Passo-a-Passo: 1. Constri-Heap: i = n/2 e vai at 1 2. Heapify (pai maior que ambos os filhos)
10 70 15 5 20 30 25

10 70 5 20 30 15 25

i=3 Heapify: maior = 2.i Troca: A[i] = A[maior]

10 70 5 20 15 30 25

Passo-a-Passo: 1. Constri-Heap: i = n/2 e vai at 1 2. Heapify (pai maior que ambos os filhos) i=2 Heapify: maior = 2.i+1 (no faz nada, pois o pai maior que ambos os filhos)

10

70
5 20 15

30 25

Passo-a-Passo: 1. Constri-Heap: i = n/2 e vai at 1 2. Heapify (pai maior que ambos os filhos)

10 70 5 20 15 30 25

i=1 Heapify: maior = 2.i Troca: A[i] = A[maior]

70 10 5 20 30

15

25

Passo-a-Passo: Constri-Heap: i = n/2 e vai at 1 Heapify (pai maior que ambos os filhos)

70 10 5 20 15 30 25

i=2 Heapify: maior = 2.i + 1 Troca: A[i] = A[maior]

70 20 5 10 15 30 25

Passo-a-Passo: 1.Algortimo HeapSort. 1.1Heapify (pai maior que ambos os filhos)

25 70

20
5 10 15

30
25 25

Troca: A[1] = A[j]

5

20 10 15

30 70 25

Passo-a-Passo: 1.Algortimo HeapSort 1.1Heapify (pai maior que ambos os filhos)

25 20 5 10 15 30

15 30

n=6 ; i=1 Heapfy: Maior: 2.i+1 Troca: A[i] = A[maior]

20
5 10 15 30

25

Algoritmo HeapSort: Troca: A[i] A[j]

70

Passo-a-Passo: 1.Algortimo HeapSort 1.1Heapify (pai maior que ambos os filhos)

15 20 25 10 10 25

n = 5; i = 1 Heapify: maior = 2.i+1 Troca: A[i] = A[maior]

20 5 25 10

15

Algoritmo HeapSort Troca: A[i]A[j]

30

70

Passo-a-Passo: 1.Algortimo HeapSort 1.1Heapify (pai maior que ambos os filhos)

10 20 5 20 5 10 20 5 15

15

n = 4; i = 1 Heapify: maior: 2.i Troca: A[i]= A[maior]

Algoritmo HeapSort Troca: A[i]A[j]

25

30

70

Passo-a-Passo: 1.Algortimo HeapSort 1.1Heapify (pai maior que ambos os filhos)

5 10 15

n = 3; i = 1 Heapify: maior = 2.i+1 Troca: A[i] = A[maior]

5 15

10

5 15

Algoritmo HeapSort Troca: A[i]A[j]

20

25

30

70

Passo-a-Passo: 1.Algortimo HeapSort 1.1Heapify (pai maior que ambos os filhos)

5 10

n = 2; i = 1 Heapify: maior = 2.i Troca: A[i] = A[maior]

5 10 10 5

Algoritmo HeapSort Troca: A[i]A[j]

15

20

25

30

70

Elementos Ordenados

10

15

20

25

30

70

http://www.cse.iitk.ac.in/users/dsrkg/cs210/applets/sorting II/heapSort/heapSort.html
http://www.cse.iitk.ac.in/users/dsrkg/cs210/applets/sorting /heapSort/heapSort.html

Captulo 04 (Ziviani)
Captulo 06 (Cormen)