classificação. 2 métodos de classificação os métodos de classificação podem ser dos tipos:...

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)

Ponto de separação ( 90 + 30 ) / 2 = 60 Posição no “array” 0 1 2 3 4 5 6 7 8 9

Posição no novo“array”

0 1 2 3 4

A trocar no novo "array"

90 55 42 71 30

0 4 90 55 42 71 30 1 2 30 55 42 71 90 30 42 55 71 90

Ponto de separação (30+42)/2=36

Posição no “array” 0 1 2 3 4 5 6 7 8 9 Posição no

novo“array” 0 1

A trocar no novo "array"

30 42

30 42 Ponto de separação ( 55 + 90

)/2=72,5 Posição no “array” 0 1 2 3 4 5 6 7 8 9

Posição no novo“array”

0 1 2

A trocar no novo "array"

55 71 90

55 71 90 Ponto de separação 55

Posição no “array” 0 1 2 3 4 5 6 7 8 9 Posição no

novo“array” 0

A trocar no novo "array"

55

55 Ponto de separação (71+90)/2=80,5

Posição no “array” 0 1 2 3 4 5 6 7 8 9 Posição no

novo“array” 0 1

A trocar no novo "array"

71 90

71 90

Resultado obtido "array"classificado 7 8 11 13 20 30 42 55 71 90

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.javapublic 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.javapublic 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.javapublic 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.javapublic 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.javapublic 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.javapublic 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;

51

A Classe Abstrata AbstractQuickSorter (3)

for(;;) {

while(i < j && array[i].isLT(pivot)) ++i; while(i < j && array[j].isGT(pivot)) --j; if(i >= j) break;

swap(i++, j--); } if(array[i].isGT(pivot))

swap(i, right); if(left < i)

sort(left, i - 1); if(right > i)

sort(i + 1, right); }

} // ...}

52

A Classe Abstrata AbstractQuickSorter (4)

// pgm15_08.javapublic abstract class AbstractQuickSorter extends AbstractSorter{ protected void sort() {

sort(0, n - 1); Sorter sorter = new

StraightInsertionSorter(); sorter.sort(array);

} // ...}

53

A Classe MedianOfThreeQuickSorter

// pgm15_09.javapublic class MedianOfThreeQuickSorter extends AbstractQuickSorter{ protected int selectPivot(int left, int right) {

int middle = (left + right) / 2; if (array[left].isGT(array[middle]))

swap(left, middle); if(array[left].isGT(array[right]))

swap(left, right); if(array[middle].isGT(array[right]))

swap(middle, right); return middle;

}}

54

StraightSelectionSort

55

A Classe StraightSelectionSorter

// pgm15_10.javapublic class StraightSelectionSorter extends AbstractSorter{ protected void sort() {

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

int max = 0; for(int j = 1; j < i; ++j)

if(array[j].isGT(array[max])) max = j;

swap(i - 1, max); }

}}

56

HeapSort

57

Construção de um Heap

58

Heap Sorting

59

A classe HeapSorter (1)

// pgm15_11.javapublic class HeapSorter extends AbstractSorter{ protected static final int base = 1;

protected void percolateDown(int i, int length) {

while(2 * i <= length) {

int j = 2 * i; if( j < length &&

array[j + 1 - base].isGT(array[j - base]) )

60

A classe HeapSorter (2)

j = j + 1; if(array[i - base].isGE(array[j - base]))

break; swap(i - base, j - base); i = j;

} } // ...}

61

A classe HeapSorter (3)

// pgm15_12.javapublic class HeapSorter extends AbstractSorter{ protected static final int base = 1;

protected void buildHeap() {

for(int i = n / 2; i > 0; --i) percolateDown (i, n);

} // ...}

62

A classe HeapSorter (4)

// pgm15_13.javapublic class HeapSorter extends AbstractSorter{ protected static final int base = 1;

protected void sort() {

buildHeap(); for(int i = n; i >= 2; --i) { swap(i - base, 1 - base); percolateDown(1, i - 1); }

} // ...}

63

Two Way Merging

64

Two Way Merge Sorting

65

A classe TwoWayMergeSorter (1)

// pgm15_14.java

public class TwoWayMergeSorter extends AbstractSorter{ Comparable[] tempArray;

// ...}

66

A classe TwoWayMergeSorter (2)

// pgm15_15.javapublic class TwoWayMergeSorter extends AbstractSorter{ Comparable[] tempArray;

protected void merge(int left, int middle, int right) {

int i = left; int j = left; int k = middle + 1;

67

A classe TwoWayMergeSorter (3)

while(j <= middle && k <= right) {

if(array[j].isLT(array[k])) tempArray[i++] = array[j++];

else tempArray[i++] = array[k++];

} while(j <= middle)

tempArray[i++] = array[j++]; for(i = left; i < k; ++i)

array[i] = tempArray[i]; } // ...}

68

A classe TwoWayMergeSorter (4)

// pgm15_16.javapublic class TwoWayMergeSorter extends AbstractSorter{ Comparable[] tempArray;

protected void sort() {

tempArray = new Comparable[n]; sort(0, n - 1); tempArray = null;

}

69

A classe TwoWayMergeSorter (5)

protected void sort (int left, int right) {

if(left < right) {

int middle = (left + right) / 2; sort(left, middle); sort(middle + 1, right); merge(left, middle, right);

} } // ...}

70

Bucket Sorting

71

A classe BucketSorter (1)

// pgm15_17.javapublic class BucketSorter extends AbstractSorter{ protected int m; protected int[] count;

public BucketSorter(int m) {

this.m = m; count = new int [m];

} protected void sort()

{ sort((Int[]) array); } // ...}

72

A classe BucketSorter (2)// pgm15_18.javapublic class BucketSorter extends AbstractSorter{ protected int m; protected int[] count;

protected void sort(Int[] array) {

for(int i = 0; i < m; ++i) count[i] = 0;

for(int j = 0; j < n; ++j) ++count[array[j].intValue()];

for(int i = 0, j = 0; i < m; ++i) for( ; count[i] > 0; --count[i])

array[j++] = new Int(i); } // ...}

73

Radix Sorting

74

A classe RadixSorter (1)

// pgm15_19.javapublic class RadixSorter extends AbstractSorter{ protected static final int r = 8; // bits da raiz protected static final int R = 1 << r; // Raiz protected static final int p = (32 + r - 1) / r; // Int com 32 bits // p número de passagens para varrer um Int protected int[] count = new int [R];

protected void sort() { sort ((Int[]) array); }

// ...}

75

A classe RadixSorter (2)

// pgm15_20.java

public class RadixSorter

extends AbstractSorter

{

protected void sort (Int[] array)

{

Int[] tempArray = new Int[n];

76

A classe RadixSorter (3)

for(int i = 0; i < p; ++i) {

for(int j = 0; j < R; ++j) count[j] = 0;for(int k = 0; k < n; ++k){

// r * i é o número de dígitos argumento do right shift // R – 1 é a máscara para R = 10000, R - 1 = 1111 ++count[( array[k].intValue() >>> (r*i) ) & (R-1)];

tempArray[k] = array[k]; } int pos = 0; for(int j = 0; j < R; ++j) { int tmp = pos; pos += count[j]; count[j] = tmp; }

77

A classe RadixSorter (4)

for(int k = 0; k < n; ++k) {

int j = ( tempArray[k].intValue() >>>

(r*i) ) & (R-1); array[count[j]++] = tempArray[k];

} }

} // ...}