AULA 23. Prof. Coelho

Transcrição

1 AULA 23 Prof. Coelho

2 Ordenação: algoritmo Quicksort PF 11 pf/algoritmos/aulas/quick.html

3 Problema da separação Problema: Rearranjar um dado vetor v[p.. r] e devolver um índice q, p q r, tais que Entra: v[p.. q 1] v[q] < v[q+1.. r] p r v

4 Problema da separação Problema: Rearranjar um dado vetor v[p.. r] e devolver um índice q, p q r, tais que Entra: Sai: v[p.. q 1] v[q] < v[q+1.. r] p r v p q r v

5 Separa p r v

6 Separa v

7 Separa v

8 Separa v v

9 Separa v v

10 Separa v v

11 Separa v v v

12 Separa v v v v

13 Separa v v v v

14 Separa v v v v

15 Separa v v v v i j v

16 Separa v v v v i j v p q r v

17 Função separa Rearranja v[p.. r] de modo que p q r e v[p.. q 1] v[q] < v[q+1.. r]. A função devolve q. int separa (int p, int r, int v[]) { 1 int i = p-1, j, c = v[r], t; 2 for (j = p; /*A*/ j <= r-1; j++) { 3 if (v[j] <= c) { 4 t=v[++i]; v[i]=v[j]; v[j]=t; } } 5 t = v[++i]; v[i] = v[r]; v[r] = t; 6 return i; }

18 Invariantes Em /*A*/ vale que (i0) v[p.. i] c < v[i+1.. j 1] (i2) v[r] = c

19 Consumo de tempo Supondo que a execução de cada linha consome 1 unidade de tempo. Qual o consumo de tempo da função separa em termos de n := r p + 1? linha 1 =? 2 =? 3 =? 4 =? 5 =? 6 =? total =? consumo de todas as execuções da linha

20 Consumo de tempo Supondo que a execução de cada linha consome 1 unidade de tempo. Qual o consumo de tempo da função separa em termos de n := r p + 1? linha 1 = 1 2 = n = n 4 n 5 = 1 6 = 1 consumo de todas as execuções da linha total 3n + 3 = O(n)

21 Conclusão O consumo de tempo da função separa é proporcional a n. O consumo de tempo da função separa é O(n).

22 Quicksort Rearranja v[p.. r] em ordem crescente. void quicksort (int p, int r, int v[]) { 1 if (p < r-1) { 2 int q = separa(p,r,v); 3 quicksort(p, q-11, v); 4 quicksort(q+1, r, v); } } p r v

23 Quicksort Rearranja v[p.. r] em ordem crescente. void quicksort (int p, int r, int v[]) { 1 if (p < r-1) { 2 int q = separa(p,r,v); 3 quicksort(p, q-11, v); 4 quicksort(q+1, r, v); } } p q r v No começo da linha 3, v[p.. q 1] v[q] < v[q+1.. r]

24 Quicksort Rearranja v[p.. r] em ordem crescente. void quicksort (int p, int r, int v[]) { 1 if (p < r-1) { 2 int q = separa(p,r,v); 3 quicksort(p, q-11, v); 4 quicksort(q+1, r, v); } } p q r v

25 Quicksort Rearranja v[p.. r] em ordem crescente. void quicksort (int p, int r, int v[]) { 1 if (p < r-1) { 2 int q = separa(p,r,v); 3 quicksort(p, q-11, v); 4 quicksort(q+1, r, v); } } p q r v

26 Quicksort Rearranja v[p.. r] em ordem crescente. void quicksort (int p, int r, int v[]) { 1 if (p < r-1) { 2 int q = separa(p,r,v); 3 quicksort(p, q-11, v); 4 quicksort(q+1, r, v); } } Consumo de tempo? T(n) := consumo de tempo no pior caso sendo n := r p + 1

27 Consumo de tempo Quanto tempo consome a função quicksort em termos de n := r p + 1? linha 1 =? 2 =? 3 =? 4 =? total =???? consumo de tempo da linha

28 Consumo de tempo Quanto tempo consome a função quicksort em termos de n := r p + 1? linha consumo de todas as execuções da linha 1 = O(1) 2 = O(n) 3 = T(k) 4 = T(n k 1) total = T(k) + T(n k 1) + O(n + 1) 0 k := q p n 1

29 Recorrência (MAC0338) T(n) := consumo de tempo máximo quando n := r p + 1 T(0)= O(1) T(1)= O(1) T(n)= T(k) + T(n k 1) + O(n) para n = 2, 3, 4,...

30 Recorrência (MAC0338) T(n) := consumo de tempo máximo quando n := r p + 1 T(0)= O(1) T(1)= O(1) T(n)= T(k) + T(n k 1) + O(n) para n = 2, 3, 4,... Recorrência grosseira: T(n) = T(0) + T(n 1) + O(n) T(n) é O(???) (MACO338).

31 Demonstração:... Recorrência (MAC0338) T(n) := consumo de tempo máximo quando n := r p + 1 T(0)= O(1) T(1)= O(1) T(n)= T(k) + T(n k 1) + O(n) para n = 2, 3, 4,... Recorrência grosseira: T(n) é O(n 2 ). T(n) = T(0) + T(n 1) + O(n)

32 Recorrência cuidadosa (MAC0338) T(n) := consumo de tempo máximo quando n = r p + 1 T(0)= O(1) T(1)= O(1) T(n)= max 0 k n 1 {T(k) + T(n k 1)} + O(n) para n = 2, 3, 4,...

33 Quicksort no pior caso O consumo de tempo da função quicksort no pior caso é proporcional a n 2. O consumo de tempo da função quicksort no pior caso é O(n 2 ). O consumo de tempo da função quicksort é O(n 2 ).

34 Quicksort no melhor caso No melhor caso, em cada chamada recursiva q é aproximadamente (p + r)/2. O consumo de tempo da função quicksort no melhor caso é proporcional a n log n. O consumo de tempo da função quicksort no melhor caso é O(n log n).

35 Discussão geral Pior caso, melhor caso, todos os casos?!?! Dado um algoritmo A o que significam as expressões: A é O(n 2 ) no pior caso. A é O(n 2 ) no melhor caso. A é O(n 2 ).

36 Análise experimental Algoritmos implementados: merger mergesort recursivo. mergei mergesort iterativo. quick quicksort recursivo. qsort quicksort da biblioteca do C.

37 Análise experimental A plataforma utilizada nos experimentos foi um computador rodando Ubuntu GNU/Linux Compilador: gcc -Wall -ansi -O2 -pedantic -Wno-unused-result. Computador: model name: Intel(R) Core(TM)2 Quad CPU 2.40GHz cpu MHz : cache size: 4096 KB MemTotal : kb

38 Tempos em segundos. Estudo empírico (aleatório) n merger mergei quick qsort

39 Estudo empírico (decrescente) n merger mergei quick qsort Tempos em segundos. Para n= quicksort dá Segmentation fault (core dumped)

40 Ambiente experimental A plataforma utilizada nos experimentos foi um computador rodando Ubuntu GNU/Linux As especificações do computador que geraram as saídas a seguir são model name: Intel(R) Core(TM)2 Quad CPU 2.40GHz cpu MHz : cache size: 4096 KB MemTotal : kb

41 Ambiente experimental Os códigos foram compilados com o gcc e com opções de compilação -Wall -ansi -O2 -pedantic -Wno-unused-result As implementações comparadas neste experimento são bubble, selecao, insercao e insercaobinaria,

42 Ambiente experimental A estimativa do tempo é calculada utilizando-se: #include <time.h> [...] clock_t start, end; double time; start = clock(); [...implementação...] end = clock(); time = ((double)(end - start))/clocks_per_sec;

43 Resultados experimentais: aleatórios n bubble selecao insercao insercaob tempos em segundos

44 Resultados experimentais: crescente n bubble selecao insercao insercaob tempos em segundos

45 Resultados experimentais: decrescente n bubble selecao insercao insercaob tempos em segundos