Classificação

1. Classificação

2. Métodos de Classificação • Os métodos de classificação podem ser dos tipos: • Classificação interna – quando toda a coleção de itens a classificar pode ficar armazenada em um “array” em memória • Classificação externa – quando as coleções de itens são muito grandes para poder permanecer armazenadas em memória

3. Regiões classificada e não classificada • Os métodos são iterativos e nos “arrays” de registros aparecem duas regiões: a região já classificada e a região de registros ainda não classificados. Em cada iteração vai crescendo a região classificada. O processo se encerra quando a região classificada abrange todo o “array”.

4. Métodos mais conhecidos • Os métodos mais conhecidos são: • Classificação por troca • Classificação por seleção • Classificação por inserção

5. Classificação por troca • Na classificação por troca comparam-se dois elementos do “array” verificando se a posição relativa do antecessor e do sucessor obedecem ao critério de classificação especificado. Caso haja obediência ao critério de classificação nada é feito. Em caso contrário trocam-se as posições destes registros. • Exemplos: • Bubble Sort • Shake Sort • Quick Sort

6. Classificação por Inserção • Na classificação por inserção em cada instante toma-se um elemento, o elemento corrente, do trecho ainda não classificado do “array” e faz-se a inserção deste elemento na posição correta do trecho já classificado. Em conseqüência reduz-se o trecho ainda não classificado e amplia-se o trecho já classificado. • Exemplos: • Inserção Simples • Shell Sort

7. Exemplo de Inserção Simples

8. Exemplo de Inserção Simples

9. Exemplo de Inserção Simples

10. Exemplo de Inserção Simples

11. Exemplo de Inserção Simples

12. Exemplo de Inserção Simples

13. Exemplo de Inserção Simples

14. Exemplo de Inserção Simples

15. Exemplo de Inserção Simples

16. Exemplo de Inserção Simples

17. Exemplo de Inserção Simples

18. Exemplo de Inserção Simples

19. Classificação por Seleção • Na classificação por seleção, em cada instante seleciona-se do trecho ainda não classificado o elemento mais apropriado para ser acrescentado ao trecho já classificado. Em conseqüência reduz-se o trecho ainda não classificado e amplia-se o trecho já classificado. • Exemplos: • Seleção Direta • Heap Sort

20. Exemplo de Seleção Direta

21. Exemplo de Seleção Direta

22. Exemplo de Seleção Direta

23. Exemplo de Seleção Direta

24. Exemplo de Seleção Direta

25. Exemplo de Seleção Direta

26. Exemplo de Seleção Direta

27. Exemplo de Seleção Direta

28. Exemplo de Seleção Direta

29. Exemplo de Seleção Direta

30. Exemplo de Seleção Direta

31. Exemplo de Seleção Direta

32. Exemplo de Quick Sort (1)

33. Exemplo de Quick Sort (2)

34. Exemplo de “Shell Sort” (1)

35. Exemplo de “Shell Sort” (2)

36. Exemplo de “Shell Sort” (3)

37. Critérios de Opção • Sugestão • Uma regra simples, que deve ser reavaliada em casos mais sensíveis, consiste em se utilizar: • Inserção simples para “arrays” com até 30 registros; • “Quick Sort” para “arrays” com mais de 30 registros.

38. Hierarquia de classes para a classificação interna

39. Interface Sorter // pgm15_01.java public interface Sorter { void sort (Comparable[]array); }

40. A Classe Abstrata AbstractSorter (1) // pgm15_02.java public abstract class AbstractSorter implements Sorter { protected Comparable[] array; protected int n; protected abstract void sort();

41. A Classe Abstrata AbstractSorter (2) public final void sort (Comparable[] array) { n = array.length; this.array = array; if(n > 0) sort(); this.array = null; } protected final void swap(int i, int j) { Comparable tmp = array[i]; array[i] = array[j]; array[j] = tmp; } }

42. Insertion Sorting

43. A Classe StraightInsertionSorter // pgm15_03.java public class StraightInsertionSorter extends AbstractSorter { protected void sort() { for(int i = 1; i < n; ++i) for(int j = i; j > 0 && array[j - 1].isGT (array [j]); --j) { swap(j, j - 1); } } }

44. A Classe BinaryInsertionSorter (1) // pgm15_04.java public class BinaryInsertionSorter extends AbstractSorter { protected void sort() { for(int i = 1; i < n; ++i) { Comparable tmp = array[i]; int left = 0; int right = i;

45. A Classe BinaryInsertionSorter (2) while(left < right) { int middle = (left + right) / 2; if(tmp.isGE(array[middle])) left = middle + 1; else right = middle; } for(int j = i; j > left; --j) swap (j - 1, j); } } }

46. Bublesort

47. A Classe BubbleSorter // pgm15_05.java public class BubbleSorter extends AbstractSorter { protected void sort() { for(int i = n; i > 1; --i) for(int j = 0; j < i - 1; ++j) if(array[j].isGT(array[j + 1])) swap(j, j + 1); } }

48. QuickSort

49. A Classe Abstrata AbstractQuickSorter (1) // pgm15_06.java public abstract class AbstractQuickSorter extends AbstractSorter { protected static final int cutOff = 2; // minimum cut-off protected abstract int selectPivot(int left, int right); // ... }

50. A Classe Abstrata AbstractQuickSorter (2) // pgm15_07.java public abstract class AbstractQuickSorter extends AbstractSorter { protected void sort(int left, int right) { if(right - left + 1 > cutOff) { int p = selectPivot(left, right); swap(p, right); Comparable pivot = array[right]; int i = left; int j = right - 1;