Classifica

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 (Comparablearray)

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 gt 0)
• sort()
• this.array null
• protected final void swap(int i, int j)
• Comparable tmp arrayi
• arrayi arrayj
• arrayj tmp

42
Insertion Sorting
43
A Classe StraightInsertionSorter

• // pgm15_03.java
• public class StraightInsertionSorter
• extends AbstractSorter
• protected void sort()
• for(int i 1 i lt n i)
• for(int j i j gt 0 arrayj - 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 lt n i)
• Comparable tmp arrayi
• int left 0
• int right i

45
A Classe BinaryInsertionSorter (2)

• while(left lt right)
• int middle (left right) / 2
• if(tmp.isGE(arraymiddle))
• left middle 1
• else
• right middle
• for(int j i j gt 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 gt 1 --i)
• for(int j 0 j lt i - 1 j)
• if(arrayj.isGT(arrayj 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 gt cutOff)
• int p selectPivot(left, right)
• swap(p, right)
• Comparable pivot arrayright
• int i left
• int j right - 1

51
A Classe Abstrata AbstractQuickSorter (3)

• for()
• while(i lt j arrayi.isLT(pivot))
  i
• while(i lt j arrayj.isGT(pivot))
  --j
• if(i gt j) break
• swap(i, j--)
• if(arrayi.isGT(pivot))
• swap(i, right)
• if(left lt i)
• sort(left, i - 1)
• if(right gt i)
• sort(i 1, right)
• // ...

52
A Classe Abstrata AbstractQuickSorter (4)

• // pgm15_08.java
• public 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.java
• public class MedianOfThreeQuickSorter
• extends AbstractQuickSorter
• protected int selectPivot(int left, int
  right)
• int middle (left right) / 2
• if (arrayleft.isGT(arraymiddle))
• swap(left, middle)
• if(arrayleft.isGT(arrayright))
• swap(left, right)
• if(arraymiddle.isGT(arrayright))
• swap(middle, right)
• return middle

54
StraightSelectionSort
55
A Classe StraightSelectionSorter

• // pgm15_10.java
• public class StraightSelectionSorter
• extends AbstractSorter
• protected void sort()
• for(int i n i gt 1 --i)
• int max 0
• for(int j 1 j lt i j)
• if(arrayj.isGT(arraymax))
• max j
• swap(i - 1, max)

56
HeapSort
57
Construção de um Heap
58
Heap Sorting
59
A classe HeapSorter (1)

• // pgm15_11.java
• public class HeapSorter
• extends AbstractSorter
• protected static final int base 1
• protected void percolateDown(int i, int
  length)
• while(2 i lt length)
• int j 2 i
• if( j lt length
• arrayj 1 - base.isGT(arrayj - base) )

60
A classe HeapSorter (2)

• j j 1
• if(arrayi - base.isGE(arrayj - base))
• break
• swap(i - base, j - base)
• i j
• // ...

61
A classe HeapSorter (3)

• // pgm15_12.java
• public class HeapSorter
• extends AbstractSorter
• protected static final int base 1
• protected void buildHeap()
• for(int i n / 2 i gt 0 --i)
• percolateDown (i, n)
• // ...

62
A classe HeapSorter (4)

• // pgm15_13.java
• public class HeapSorter
• extends AbstractSorter
• protected static final int base 1
• protected void sort()
• buildHeap()
• for(int i n i gt 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.java
• public 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 lt middle k lt right)
• if(arrayj.isLT(arrayk))
• tempArrayi arrayj
• else
• tempArrayi arrayk
• while(j lt middle)
• tempArrayi arrayj
• for(i left i lt k i)
• arrayi tempArrayi
• // ...

68
A classe TwoWayMergeSorter (4)

• // pgm15_16.java
• public class TwoWayMergeSorter
• extends AbstractSorter
• Comparable tempArray
• protected void sort()
• tempArray new Comparablen
• sort(0, n - 1)
• tempArray null

69
A classe TwoWayMergeSorter (5)

• protected void sort (int left, int right)
• if(left lt 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.java
• public 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.java
• public class BucketSorter
• extends AbstractSorter
• protected int m
• protected int count
• protected void sort(Int array)
• for(int i 0 i lt m i)
• counti 0
• for(int j 0 j lt n j)
• countarrayj.intValue()
• for(int i 0, j 0 i lt m i)
• for( counti gt 0 --counti)
• arrayj new Int(i)
• // ...

73
Radix Sorting
74
A classe RadixSorter (1)

• // pgm15_19.java
• public class RadixSorter
• extends AbstractSorter
• protected static final int r 8 // bits da
  raiz
• protected static final int R 1 ltlt 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 Intn

76
A classe RadixSorter (3)

• for(int i 0 i lt p i)
• for(int j 0 j lt R j)
• countj 0
• for(int k 0 k lt 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( arrayk.intValue() gtgtgt (ri) )
  (R-1)
• tempArrayk arrayk
• int pos 0
• for(int j 0 j lt R j)
• int tmp pos
• pos countj
• countj tmp

77
A classe RadixSorter (4)

• for(int k 0 k lt n k)
• int j ( tempArrayk.intValue() gtgtgt
• (ri) ) (R-1)
• arraycountj tempArrayk
• // ...