Ordenação (Sorting) Ordenar é dispor os elementos de um conjunto numa ordem ascendente ou descendente. Problema: Dados n números, arranjá-los em ordem crescente ou decrescente.

Insertion Sort: Problema Dados n números em uma ordem arbitrária. Por indução, sabemos como ordenar n-1 números Temos que colocar o n-ésimo número no lugar correto. Como podemos resolver este problema? - A base da indução é o primeiro elemento, a 1. - Passamos ao próximo elemento, a 2, e procuramos sua posição correta, comparando-o com o elemento a 1. Se a 1 for maior que a 2, trocamos a posição dos dois elementos. - Em seguida passaremos ao próximo elemento, a 3, etc.

Insertion Sort

Algoritmo Insertion Sort Entrada : um array e o seu número de elementos (item, number) Saída : o array ordenado begin int i, j, t for i := 2 to number do t := item[i]; j := i-1; while j  1 and t < item[j] do item[j+1] := item[j]; j := j-1; item[j+1] := t; end

Exemplo de Insertion Sort

Complexidade do Insertion Sort Para um elemento genérico i no conjunto dado, no pior caso, devemos compará-lo com todos os i -1 elementos que o antecedem. Uma vez que o conjunto possui n elementos, o número total de comparações é dado pela soma: n-1 = Resultando na complexidade: O(n 2 ) n (n-1) 2

Mergesort Problema Ordenar um dado conjunto de n números. Uma nova abordagem: Dividir-para-Conquistar 1. Dividir o problema em sub-problemas (menores) 2. Resolver estas novas instâncias (recursivamente) 3. Intercalar os resultados desses sub-problemas para achar a solução do problema principal.

MergeSort Lista 2 2 Lista1 3 1

Algoritmo do Mergesort Entrada : (A, B, ini, fim) Saída : B [ ini.. fim], o array A ordenado de ini até fim begin if (fim = ini) retorne(*); else MergeSort (A, B, ini, (ini + fim)/2 ); MergeSort (A, B, (ini + fim)/2 +1, fim); Intercala (A, B, ini, (fim-ini)/2 +1, (fim-ini+1)/2 ); retorne(*); end (*) O array com a resposta depende do tamanho de A.

Algoritmo Intercala Entrada: (A, B, ini, m, n) Saída: Elementos B[ini.. ini+m+n-1] ordenados begin int i:=1, j:=1, k:=1; while ( i  m and j  n ) do if(A[i]  B[j] ) then { C[k] := A[i] i := i+1; k := k+1 } else { C[k] := B[j] j := j+1; k := k+1 } while ( i  m) do { C[k] := A[i]; k := k+1; i := i+1 } while ( j  n) do { C[k] := B[j]; k := k+1; j := j+1 } retorne( C ); end

Exemplo de MergeSort

Complexidade do Mergesort T Mergesort (tamanho) = 2*T Mergesort (Tamanho/2) + cte*tamanho + cte Forma Fechada de Recorrência T MS = 2*T MS (n/2) + c*n + c = 2*[ 2*T MS (n/4) + c*n/2 + c ] + c*n + c = 4*T MS (n/4) + 2c*n + 3c = 4*[ 2*T MS (n/8) + c*n/4 + c ] + 2c*n + 3c = 8*T MS (n/8) + 3c*n + 7c =... = 2 i *T MS (n/2 i ) + i*c*n + (2 i -1)*c T MS (1) ==> (n/2 i ) = 1

Complexidade do Mergesort Quando i = log 2 n T MS (n) = 2 log 2 n * cte + (log 2 n)*c*n + (2 log 2 n - 1) *c T MS = n*cte + c*n*log 2 n + c*(n-1) T MS = c*nlog 2 n + (cte+c)*n - c T MS (n) = O(n * log 2 n)