Programação II Laboratório II Prof. Mateus Raeder Universidade do Vale do Rio dos Sinos - São...

Programação IILaboratório II

Prof. Mateus Raeder

Universidade do Vale do Rio dos Sinos- São Leopoldo -

Transparências baseadas nos originais da Prof. Patrícia Jaques

Programação II – Prof. Mateus Raeder

Classificação de Dados


• Processo de organizar itens em ordem (de)crescente, segundo algum critério

• Também chamado de ordenação• Aplicações de Sorting

– Preparação de dados para facilitar pesquisas futuras• Exemplo: dicionários e listas telefônicas

– Agrupar itens que apresentam mesmos valores• Para eliminação de elementos repetidos

– Batimento entre itens presentes em mais de um arquivo• Para combinação de dados presentes nos vários arquivos• Para consolidação dos vários arquivos em um único

Classificação


• Sejam R1, R2, …, RN , N ítens (chamados registros)

• Cada registro Ri, é formado por uma chave Ci e por informações ditas satélites

• A ordenação dos registros é feita definindo-se uma relação de ordem “<“ sobre os valores das chaves

• O objetivo da ordenação é determinar uma permutação dos índices 1 i1, i2, …, iN N das chaves, tal que Ci1 Ci2 … CiN.

• Um conjunto de registros é chamado de arquivo

Definições


• Uma relação de ordem “<“ (leia-se precede) deve satisfazer as seguintes condições para quaisquer valores a, b e c:(i) Uma e somente uma das seguintes possibilidades é

verdadeira: a < b, a = b ou b < a (lei da tricotomia)(ii) Se a < b e b < c, então a < c (transitividade)

• As propriedades (i) e (ii) definem o conceito de ordem linear ou ordem total

Relação de Ordem


• Escreva um algoritmo para classificar um conjunto de 5 números em ordem crescente.

Exercício


– Reorganização Física – Encadeamento– Vetor Indireto de Ordenação (VIO)

Formas de Representação do Resultado


10

19

13

12

7

1

2

3

4

5

chave

(a) antes da classificação

7

10

12

13

19

1

2

3

4

5

chave

(b) após a classificação

Reorganização Física


10

19

13

12

7

1

2

3

4

5

chave

(a) antes da classificação (b) após a classificação

10

19

13

12

7

1

2

3

4

5

chave

4

02

3

1

5

cabeça da listaEncadeamento


10

19

13

12

7

1

2

3

4

5

Chave Chave VIO

1

2

3

4

5

5

1

4

3

2

7

10

12

13

19

Vetor Indireto de Ordenação


– Classificação por Inserção• Inserção Direta• ShellSort

– Classificação por Trocas (permutação) • BubbleSort• QuickSort

– Classificação por Seleção• Seleção Direta• HeapSort

Métodos de Classificação


• A classificação é obtida porque os elementos são inseridos na sua posição correta.

• Algoritmos:– Inserção Direta– ShellSort

Classificação por Inserção


Inserção Direta• Mais simples

• Normalmente utilizado para um conjunto pequeno de dados, pois apresenta baixa eficiência

• Divide o vetor em 2 segmentos:– o primeiro contendo os elementos já ordenados– o segundo contendo os elementos ainda não ordenados

• Funcionamento: Pega o primeiro elemento do segmento não ordenado e procura seu lugar no segmento ordenado.

• No início: o 1º segmento terá apenas 1 elemento


18 15 7 9 23 16 14

18 15 7 9 23 16 14

15 18 7 9 23 16 14

7 15 18 9 23 16 14

Vetor original

Divisão inicial

Não ordenado

Ordenado

...

Primeira iteração

Segunda iteração

Inserção Direta


public static void insertionSort (int a[]) { for (int i = 1; i < a.length; i++) {

int j = i; // pos do 1º elemento no seg. não ord. int B = a[i]; // 1º elemento no seg. não ord. while ((j > 0) && (a[j-1] > B)) {

a[j] = a[j-1]; j--;

}a[j] = B;

} } // do método

18 15 7 9 23 16 14

0 1 2 3 4 5 6

buscando a posiçãodo 1º elemento do segmento não ordenado no segmento ordenado

Inserção Direta


• Proposto por Ronald Shell em 1959.

• Explora as seguintes características do método de inserção direta:– desempenho aceitável quando o número de chaves é pequeno;– desempenho aceitável quando as chaves já possuem uma ordenação

parcial.

• É considerado uma extensão do método de inserção direta, pois se diferencia deste apenas no nro. de segmentos considerados.

• Realiza classificações parciais do vetor a cada iteração, favorecendo o desempenho dos passos seguintes.

ShellSort


• Método de classificação:– No primeiro passo, o vetor C [ n ] é dividido em h

segmentos, de tal forma que cada um possua n / h chaves

– Cada um dos segmentos é classificado por inserção direta, separadamente

– No passo seguinte, o incremento h é diminuído (a metade do valor anterior, se este era potência inteira de 2) incrementos decrescente

– No último passo, h = 1 h=22=4h=21=2h=20=1

3 passos

ShellSort


• Testes empíricos sugerem que a melhor escolha para os valores de h é a sequência

• <(3t-1)/2, ..., 13, 4, 1> onde

• ht = 3ht-1+1– 3*0+1 = 1– 3*1+1 = 4– 3*4+1 = 13– 3*13+1 = 40

ShellSort


17 25 49 12 18 23 45 38 53 42 27 13 11

0 1 2 3 4 5 6 7 8 9 10 11 12

Original

1 2 3 4 1 2 3 4 1 2 3 4 1

0 1 2 3 4 5 6 7 8 9 10 11 12

Primeiro passo: h = 411 23 27 12 17 25 45 13 18 42 49 45 53

11 12 13 17 18 23 25 27 38 42 45 49 53

0 1 2 3 4 5 6 7 8 9 10 11 12

Último passo: h=1

ShellSort


public static void shellSort(int a[]) { int h = 1; // acha o maior valor possível para h while ((h * 3 + 1) < a.length) h = 3 * h + 1; // h=4 while( h > 0 ) { // para cada segmento de elem. (há h segm.) for (int i = h; i < a.length; i++) { int B = a[i]; int j = i;

// compara B com o elemento antes dele no conjunto //e assim por diante até achar o lugar de B while ((j >= h) && (a[j - h] > B)) { a[j] = a[j - h]; j -= h; } a[j] = B; } h = h / 3; } }

ShellSort

1 2 3 4 1 2 3 4 1 2 3 4 1

0 1 2 3 4 5 6 7 8 9 10 11 12

11 23 27 12 17 25 45 13 18 42 49 45 53


• Caracterizam-se por efetuarem a classificação por comparação entre pares de chaves, trocando-as de posição caso estejam fora de ordem no par.

• Algoritmos:– BubbleSort– QuickSort

Classificação por Trocas


Primeira Varredura

28 26 30 24 25 compara par (28, 26) : troca

26 28 30 24 25 compara par (28, 30) : não troca



26 28 24 25 30 fim da primeira varredura

Exemplo: Suponha que se deseja classificar em ordem crescente o seguinte vetor de chaves:

28 26 30 24 25

Método da Bolha (BubbleSort)


Segunda Varredura

26 28 24 25 30 compara par (26, 28) : não troca



26 24 25 28 30 fim da segunda varredura



24 25 26 28 30 fim da terceira varredura

Terceira Varredura



public static void bubbleSort(int a[]) { for (int i = a.length-1; i>0; i--) { // nro de

varredurasfor (int j = 0; j<i; j++) { // percorre vetor

if (a[j] > a[j+1]) { // troca par de posição

int T = a[j]; a[j] = a[j+1]; a[j+1] = T;

}}

}}




Considerando o seguinte vetor :

13 11 25 10 18 21 23

1) Em quantas varreduras o vetor é classificado ?

2) Como identificar, a partir da última varredura, quantas chaves já estão classificadas?


Considerando o seguinte vetor :

13 11 25 10 18 21 23

1) Em quantas varreduras o vetor é classificado ?

2) Como identificar, a partir da última varredura, quantas chaves já estão classificadas?

Observe que a quantidade de chaves, a partir da última, que pode ser ignorada de uma varredura para a outra é conhecida pela posição na qual ocorreu a última troca.A partir daquele ponto o vetor já se encontra classificado!



public static void bubbleSort(int a[]) { for (int i = a.length-1; i>0; i--) { // nro. de

varreduras boolean flipped = false;for (int j = 0; j<i; j++) {

if (a[j] > a[j+1]) { // troca par de posição

int T = a[j]; a[j] = a[j+1]; a[j+1] = T; flipped = true;

} }if (!flipped) return;

}}

Método da Bolha (BubbleSort)Uma melhoria no algoritmo, para parar caso já esteja ordenado:


• Análise do Desempenho do melhor caso– aquele no qual as chaves já se encontram na ordem desejada– na primeira varredura o método já terá descoberto que o vetor já se

encontra ordenado– número de comparações efetuadas ?

• n-1

• Análise do desempenho do pior caso– chaves do vetor se encontram na ordem inversa a desejada– a cada varredura apenas uma chave será colocada no seu lugar definitivo;

as demais se deslocarão uma posição para a esquerda (em ordenação crescente)



A idéia básica é a de dividir o problema, de ordenarum conjunto de n itens em dois problemas menores.

A seguir, os problemas menores são ordenadosindependentemente e depois os resultados são combinados

para produzir a solução do problema maior!

(Ziviani, 1996)

Método QuickSort


QuickSort• 1) Dividir

– Escolher um elemento da array como pivô (x);– Particionar:

• elementos < pivô primeira parte• elementos > pivô segunda parte


• Princípio de classificação– inicialmente, o vetor de chaves C é particionado em três

segmentos S1, S2 e S3

– S2 terá comprimento 1 e conterá uma chave denominada particionadora ou pivô

– S1 terá comprimento 0 e conterá todas as chaves cujos valores são menores ou iguais ao da chave particionadora. Esse segmento está posicionado à esquerda de S2

– S3 terá comprimento 0 e conterá todas as chaves cujos valores são maiores do que o da chave particionadora. Esse segmento está posicionado à direita de S2

QuickSort


Vetor Inicial : C [ 1 .. n ]1 n

Vetor Particionado1 n

S1 S2 S3

K - 1 k K + 1

Onde: C [ i ] C [ k ] , para i = 1, … , k - 1C [ i ] > C [ k ] , para i = k + 1 , … , n

QuickSort


• Princípio de classificação (continuação … )– o processo de particionamento é reaplicado aos

segmentos S1 e S2 e a todos os segmentos correspondentes daí resultantes, que tiverem comprimento 1

– quando não restarem segmentos a serem particionados, o vetor estará ordenado

– qual é a chave particionadora ideal ? Como escolher essa chave ?

QuickSort


• Escolhendo a chave particionadora ...– para simplificar o algoritmo de particionamento,

pode-se arbitrar que a chave que se encontra na posição inicial do vetor a ser particionado será a particionadora

– se existe conhecimento prévio sobre a distribuição dos valores das chaves e o vetor já se encontra parcialmente ordenado, a chave que se encontra na posição central do vetor pode ser a eleita

QuickSort


public static void quickSort (int[] a, int lo, int hi){ int i=lo, j=hi, h; int x=a[(lo+hi)/2]; // partition do { while (a[i]<x) i++; while (a[j]>x) j--; if (i<=j) { h=a[i]; a[i]=a[j]; a[j]=h; i++; j--; } } while (i<=j); // recursion if (lo<j) quickSort(a, lo, j); if (i<hi) quickSort(a, i, hi); }

QuickSort


Quick Sortvoid quicksort (int[] a, int lo, int hi){ int i=lo, j=hi, h; int x=a[(lo+hi)/2];

// partition do { while (a[i]<x) i++; while (a[j]>x) j--; if (i<=j) { h=a[i]; a[i]=a[j]; a[j]=h; i++; j--; } } while (i<=j);

// recursion if (lo<j) quicksort(a, lo, j); if (i<hi) quicksort(a, i, hi);}

lo x=a[4] hi

i j

0 1 2 3 4 5 6 7 8 9

quicksort(a, 0, a.length-1)

i ji j

i j 0 1 2 3 4 5 6 7 8 9

0 1 2 3 4 5 6 7 8 9

i j 0 1 2 3 4 5 6 7 8 9

ij

quicksort(a, 0, 3)quicksort(a, 5, 9)





lox=a[1]hi 0 1 2 3 4 5 6 7 8 9

i j

quicksort(a, 0, 0)quicksort(a, 2, 3)

lo hix=a[7]

i jj

ij

0 1 2 3

i i i j

ij i

quicksort(a, 5, 8)

0 1 2 3 4 5 6 7 8 9





0 1 2 3 4 5 6 7 8 9

lo hix=a[6]

i j 0 1 2 3 4 5 6 7 8 9

i j

quicksort(a, 5, 6)

lo hi

x=a[2]

i

ij ij

j

j i


Exercício:

Suponha que se deseja classificar o seguinte vetor:

G R E M I S T A

Suponha que a chave particionadora está na posiçãono meio do vetor.

Simule as iterações necessárias para a classificação,segundo o algoritmo apresentado.

Quick Sort


• Caracterizam-se por procurarem, a cada iteração, a chave de menor (ou maior) valor do vetor e colocá-la na sua posição definitiva correta, qual seja, no início (ou no final) do vetor, por permutação com a que ocupa aquela posição!

• Algoritmos:– Seleção Direta– HeapSort

Classificação por Seleção

• Princípio de classificação– a seleção da menor chave é feita por pesquisa

seqüencial– a menor chave encontrada é permutada com a

que ocupa a posição inicial do vetor, que fica reduzido de um elemento

– o processo de seleção é repetido para a parte restante do vetor, até que todas as chaves tenham sido selecionadas e colocadas em suas posições definitivas

Classificação por Seleção Direta


Suponha que se deseja classificar o seguinte vetor:

9 25 10 18 5 7 15 3

Simule as iterações necessárias para a classificação.



Iteração Vetor Chave Permutação Vetor orde-Selecionada nado até a

posição

1 9 25 10 18 5 7 15 3 3 9 e 32 3 25 10 18 5 7 15 9 5 25 e 5 13 3 5 10 18 25 7 15 9 7 10 e 7 24 3 5 7 18 25 10 15 9 9 18 e 9 35 3 5 7 9 25 10 15 18 10 25 e 10 46 3 5 7 9 10 25 15 18 15 25 e 15 57 3 5 7 9 10 15 25 18 18 25 e 18 68 3 5 7 9 10 15 18 25 8



public static void selectionSort (int a[]) { int min=0, ch; for (int i=0; i<a.length-1; i++) { min = i; // mínimo inicial for (int j = i + 1; j<a.length; j++) if (a [ j ] < a [ min ]) min = j; // acha o novo mínimo ch = a [ i ]; a [ i ] = a [ min ] ; // coloca o novo mínimo a [ min ] = ch; // na posição correta } }



Programação II Laboratório II Prof. Mateus Raeder Universidade do Vale do Rio dos Sinos - São...

Documents

Transcript of Programação II Laboratório II Prof. Mateus Raeder Universidade do Vale do Rio dos Sinos - São...