Ordenação

IF672 - Algoritmos e Estruturas de Dados CIn - UFPE

[email protected]

OrdenaçãoOrdenar é dispor os elementos em ordem ascendente

ou descendente.

Dados n números, arranjá-los em ordem crescente.

Sortings:

• Heapsort

• Quicksort

• Mergesort

HeapsortOrdenação de um conjunto de elementos com um

heap.

Primeiro passo: construção do heap.

Selecionamos e posicionamos o maior elemento do conjunto, trocando o primeiro com o último elemento.

Decrementamos o tamanho do heap.

Rearranjamos o heap.

Continua com as sucessivas trocas do primeiro com o último elemento e rearranjos do heap.

HeapsortApós tudo isso, o array é visto como contendo um heap mais a

parte da solução.

Então, o uso da estrutura heap permite que:

• O elemento máximo do conjunto seja determinado e corretamente posicionado no vetor em tempo constante, trocando o primeiro elemento do heap com o último.

• Número de trocas de elementos proporcional à altura da árvore.

Heapsort

34

21

41

22

74

26 9

74 2241 21 934 26

22921

34

41

26

74

74 22 41 21 9 34 26

41 2234 21 926 74

921

26

7441

22

34

41 26 34 21 9 22 74

921

26

7422

34

41

41 26 34 21 9 22 74 412634 21 922 74

Heapsort

349

21

7441

22

26

34 26 22 21 9 41 74

921

26

7441

22

34

34 26 22 21 9 41 74 412126 9 3422 74

Heapsort

3426

21

7441

9

22

26 21 22 9 34 41 74

349

21

7441

22

26

26 21 22 9 34 41 74 412122 26 349 74

Heapsort

3426

9

7441

22

21

22 21 9 26 34 41 74

3426

21

7441

9

22

22 21 9 26 34 41 74 41921 26 3422 74

Heapsort

3426

21

7441

22

9

21 9 22 26 34 41 74

3426

9

7441

22

21

21 9 22 26 34 41 74 41219 26 3422 74

Heapsort

HeapsortChamada:Implementação:

heapsort(array, array.length);

void heapsort (int array[], int n) {

constroiHeap (array, n);

int tamanhoDoHeap = n;

for(int i = n-1; i>0; i--) {

troca (array[0], array[i]);

--tamanhoDoHeap;

heapfy (array,tamanhoDoHeap,0);

}

}

QuicksortOrdenação simples de implementar em linguagens

com recursão.

Método “dividir para conquistar”.

Particiona o arquivo em duas partes, ordenando as partes independentes.

QuicksortDividir para Conquistar

Dividir: Particione o array em dois subarrays ao

redor de um pivô x de forma que elementos no subarray inferior ≤x≤ elmentos no subarray superior.

Obs: a posição do elementos iguais à chave deve ser especificada, dependendo do objetivo da implementação.

QuicksortEscolha um elemento (pivô) e coloque-o no início da

lista.

Varra o array a partir da esquerda até encontrar um elemento que seja maior que o pivô e pela direita até encontrar um elemento menor que o pivô.

Os dois devem ser trocados de lugar.

Quando os ponteiros se cruzam, troque o pivô com o elemento mais a esquerda do array.

Quicksort: Exemplo Particiona






QuicksortFunção Particiona

Implementação:int particiona (int array[], int i, int f) {

int a = i+1; int b = f; int pivo = array[i];

while(a <= b) {

while(a<=f && array[a]<pivo) a++;

while(array[b]>pivo) b--;

if(a < b) troca (array[a], array[b]);

}

troca(array[b], array[i]); return b;

}

QuicksortChamada:

Implementação:

void quicksort (int array[], int i, int f) { if (i < f) {

int p = particiona (array, i, f);

quicksort (array, i, p-1);

quicksort (array, p+1, f);

}

}

quicksort(array, 0, array.length-1);

QuicksortConsiderações finais

• Quicksort é um ótimo algoritmo de ordenação de propósito geral.

• Quicksort é normalmente mais rápido que o Mergesort, mas no pior caso tem custo O(n²).

MergesortAlgoritmo particular de ordenação.

Método “dividir para conquistar”.

Divide o array no meio.

Ordena cada metade com Mergesort novamente.

Junta (merge) as partes já ordenadas.

Problema: necessita de um espaço igual ao dobro do tamanho da lista a ser ordenada.

Mergesort

82 3670 72 2511 44 10

82 3670 72 2511 44 10

82 70 36257211 44 10

82 70 7211 3625 44 10

Mergesort

10 7011 36 4425 72 82

82 3670 72 2511 44 10

70 82 36257211 10 44

11 70 8272 2510 36 44

MergesortChamada:

Implementação:

void mergesort(int array[], int i, int f) {

if (i < f) {

int mid = (i+f)/2;

mergesort (array, i, mid);

mergesort (array, mid+1, f);

intercala (array, i, mid, f);

}

mergesort(array, 0, array.length-1);

MergesortFunção Merge/Intercala

11 70 8272 2510 36 44

Divisão da direita Divisão da esquerda

a b


10

11 70 8272 2510 36 44


a b


10 11

11 70 8272 2510 36 44


a b


10 11 25

11 70 8272 2510 36 44


a b


10 11 3625

11 70 8272 2510 36 44


a b


10 11 36 4425

11 70 8272 2510 36 44


a b


10 7011 36 4425 72 82

11 70 8272 2510 36 44


a b

MergesortImplementação Merge/Intercalavoid intercala (int array[], int left, int mid, int right) {

int i = left;int j = mid + 1;int k = left - 1;while (i <= mid && j <= right) {

k++;if (array[i] <= array[j]) {

temp[k] = array[i];i++;

} else {temp[k] = array[j];j++;

}}

//...}

MergesortImplementação Merge/Intercalavoid intercala (int array[], int left, int mid, int right) {

while (i <= mid) {temp[k] = array[i]; i++; k++;

}

while (j <= right) {temp[k] = array[j]; j++; k++;

}

}

Relembrando:Busca BináriaBusca eficiente feita em um array ordenado.

A busca é iniciada pelo elemento central. Se o elemento procurado for menor, procura-se novamente na primeira metade, caso contrário, na segunda.

A

x < A x > A

B

x < B x > B

C

x < C x > C

Relembrando:Busca BináriaBusca bem sucedida: número 8

1 2 4 5 8 10 11 20 25 32 33 37 39 46 50

i = 0 f = 14m = 7

1 2 4 5 8 10 11

i = 0 f = 6m = 3

8 10 11

i = 0 f = 6m = 5

8

i = m = f = 5

8 < 20

8 > 5

8 < 10

Relembrando:Busca BináriaBusca mal sucedida: número 28

1 2 4 5 8 10 11 20 25 32 33 37 39 46 50

i = 0 f = 14m = 7

25

i = m = f = 8

28 > 20

i = 8 f = 14m = 11

25 32 33 37 39 46 50

i = 8 f = 10m = 9

25 32 33

28 < 37

28 < 32

Relembrando:Busca BináriaChamada:

Implementação:

int bs(int array[], int i, int f, int x) { int mid = (i+f)/2;

if (x == array[mid]) // caso base 1 (encontrado) return mid; else if (i >= f) // caso base 2 (não existe) return –1;

else if (x < array[mid]) // caso indutivo return bs(array, i, mid-1, x) else return bs(array, mid+1, f, x)}

bs(array, 0, array.length-1, x);

IF672 - Algoritmos e Estruturas de Dados CIn - UFPE

[email protected]

Documents

Ordenação