Entrada: M ind

Transcrição

1 Ordenação O objetivo deste capítulo é o de estudar algoritmos de ordenação (ou classificação) de uma sequência de números, em ordem crescente, ou decrescente. De um modo geral tal sequência pode ser uma lista extensa como a lista telefônica de S. Paulo, ou a lista de assinantes de TV, etc. No caso de uma lista telefônica, tem-se nomes de pessoas a serem ordenados em ordem alfabética. Dados um inteiro positivo N e uma sequência M de N números em ponto flutuante, ordenar esta sequência em ordem crescente. Por exemplo: N 4 Entrada: M ind

2 Saída: M ind Idéia do algoritmo-solução: Este algoritmo é chamado de bubble-sort, i.e., ordenação por bolha: o porquê deste nome ficará claro mais tarde. A idéia do algoritmo é a seguinte: primeiro compare M 0 com M 1 ;sem 0 M 1 então troque os valores entre si para tê-los em ordem crescente. Em seguida faça o mesmo com M 1 e M 2,e depois com M 2 e M 3 etc., até M N 2 e M N 1. Durante a sequência de comparações e possíveis trocas os números maiores vão sendo deslocados para a direita em M. De fato o maior número em M é deslocado para a direita até se tornar M N 1 e então ele deve permanecer nesta posição. Repetimos então o processo descrito acima para a sub-sequência

3 M 0,M 1,...,M N 2 deslocando o número apropriado para a posição M N 2. Repetindo este processo para as sub-sequências cada vez mais curtas, acabaremos ordenando todos os números em ordem crescente (a rigor é em ordem não-decrescente).

4 1inteiroi, j, /* variáveis índice */ 2 N; /* número de elementos na sequência */ 3 real M 50 ; /* vetor de até 50 elementos */ 4leiaN; 5parai 0atéN 1 faça 6 leia M i ; 7paraj N 2até0faça 8 para i 0atéjfaça /* supor que M 0, M 1,,...,M j 1 */ /* não estão em ordem */ 9 se M i M i 1 então 10 troque os valores de M i e M i 1 entre si ; 11 para i 0atéN 1 faça 12 escreva M i ;

5 N 4 j i M i M i 1 sequência resultante , 47. 0, 0. 6, , 0. 6, 47. 0, ,0.6, 9. 5, , 5. 1, 9. 5, , 9. 5, 5. 1, , 0. 6, 5. 1, 47. 0

6 Programa em linguagem C: algoritmo bubble /* * ORDEBOL. C-- Ordenacao por Bolha * Problema: dada uma sequencia de N numeros reais (tipo float) * ordena -la em ordem crescente. */ #include stdio.h #define Nmax 100 /* Numero maximo de elementos a ordenar */ void main() { int N, /* numero de elementos a ordenar */ i, j; float M[Nmax], /* vetor de N elementos */ temp; /* variavel temporaria */ /* * Leitura dos parametros */ printf("\ndigitar o numero de elementos a ordenar - "); scanf("%d", &N); printf("\nn %d\n", N); if(n Nmax){ printf("\nnumero maximo de elementos foi excedido\n"); exit(0); } /*end if */ printf("digitar os elementos a serem ordenados - "); for(i 0; i N-1; i i 1) scanf("%f", &M[i]); printf("\n"); for(i 0; i N-1; i i 1){ printf(" M[%d] %f", i, M[i]); } /* end for i */ /* * Ordenacao dos elementos em M[], em tempo proporcional a N*N */ if(n 2) for(j N-2; j 0; j j-1) for(i 0; i j; i i 1) if(m[i] M[i 1]){ temp M[i 1]; M[i 1] M[i]; M[i] temp; } /* end for i */ /* * Dar resposta final */ printf("\n Elementos em ordem crescente:\n"); for(i 0; i N-1; i i 1){ printf(" M[%d] %f ", i, M[i]); } /* end for i */ } /* end main */

7 Idéia de um outro algoritmo-solução: ordenação por seleção direta Vamos lembrar qual é o problema original: Dados um inteiro positivo N e uma sequência R de N números em ponto flutuante, ordenar esta sequência em ordem crescente. Vamos ver um outro algoritmo chamado de ordenação por seleção direta do mínimo: o porquê deste nome ficará claro mais tarde. A idéia do algoritmo é a seguinte: 1. Dentro de um laço no qual uma variável indexadora i variade0 a N 1, é mantida uma outra variável indexadora IndMin que é o índice do elemento mínimo sendo procurado. R i IndMin 0 2. No início de cada execução do laço, IndMin é inicializado para i, ou seja, supõe-se por enquanto que o elemento mínimo seja o

8 primeiro na sequência R i,r i 1,...,R N A seguir compara-se R IndMin com cada um dos elementos na sequência R i, R i 1,...,R N 1 : a. se R IndMin R i 1 então efetuamos IndMin i 1, ou seja, o novo elemento mínimo passa a ser R i 1. b. se R IndMin R i 2 então efetuamos IndMin i 2, e assim por diante. c. no final, compara R IndMin e R N 1, d. e então trocamos entre si os elementos R IndMin e R i,istoé,r i deve conter o elemento mínimo da sequência R i,r i 1,...,R N A seguir o mesmo processo deve ser feito para a sequência R i 1,R i 2,...,R N 1. R i IndMin 1

9 1inteiroi, j, /* variáveis índice */ 2 N; /* número de elementos na sequência */ 3 real R 50 ; /* vetor de até 50 elementos */ 4leiaN; 5parai 0atéN 1 faça 6 leia R i ; 7parai 0atéN 2 faça 8 IndMin i; /* por enquanto o mínimo é R i */ 9 para j i 1atéN 1 faça /* procurar o mínimo em */ 10 /* R i 1,R i 2,,...,R N 1 */ 11 se R IndMin R j então IndMin j; 12 troque entre si R IndMin e R i ; 13 para i 0atéN 1 faça 14 escreva R i ; Simulação do algoritmo por seleção direta: Vamos supor que a sequência de entrada seja a mesma descrita no

10 exemplo acima, com N 4. i IndMin j R IndMin R j sequência resultante R ,R , R ,R R 0-9.5, R , R ,R

11 i IndMin j R IndMin R j sequência resultante R ,R 1 0.6, R ,R R ,R , R 2 5.1, R Programa em linguagem C: algoritmo de ordenação por seleção direta

12 /* * ORDEDIR.C--Exemplo de Ordenacao por Selecao Direta * Problema: dada uma sequencia de N numeros reais (tipo float) * ordena -la em ordem crescente. */ #include stdio.h #define Nmax 100 /* Numero maximo de elementos em R[] */ void main() { int N, /* numero de elementos em R[] */ i, j, IndMin; /* indice do minimo temporario */ float R[Nmax], /* vetor de N elementos */ temp; /* variavel temporaria */ /* * Leitura dos parametros */ printf("\ndigitar o numero de elementos de R[] - "); scanf("%d", &N); printf("\nn %d\n", N); if(n Nmax){ printf("\nnumero maximo de elementos foi excedido\n"); exit(0); } /*end if */ printf("digitar os elementos de R[] a serem ordenados - "); for(i 0; i N; i i 1) scanf("%f", &R[i]); printf("\n"); for(i 0; i N; i i 1){ printf("r[%d] %f", i, R[i]); } /* end for i */ /* * Ordenacao dos elementos em R[], em tempo proporcional a N*N */ for(i 0; i N-2; i i 1){ IndMin i; /* indice do Minimo temporario */ for(j i 1; j N-1; j j 1){ if(r[indmin] R[j]) IndMin j; } /* end for j */ temp R[IndMin]; R[IndMin] R[i]; R[i] temp; } /* end for i */ /* * Dar resposta final */ printf("\n Elementos de R[], em ordem crescente:\n"); for(i 0; i N; i i 1){ printf(" R[%d] %f ", i, R[i]); } /* end for i */ } /* end main */

13 Idéia de um terceiro algoritmo-solução: ordenação por inserção direta Vamos lembrar qual é o problema original: Dados um inteiro positivo N e uma sequência R de N números em ponto flutuante, ordenar esta sequência em ordem crescente. Vamos ver um terceiro algoritmo chamado de ordenação por inserção direta: o porquê deste nome ficará claro mais tarde. A idéia do algoritmo é a seguinte: R R R R i 1 i 1 temp R 1 1. Dentro de um laço no qual uma variável indexadora i variade1 a N 1, é considerada a sequência R 0,R 1,...,R i 1, R i eé mantida uma variável temporária temp. Noiníciodecada execução do laço, temp é inicializado para R i.

14 2. A seguir compara-se temp com cada um dos elementos na sequência R 0, R 1,...,R i 2,R i 1,dadireita para a esquerda:se R i 1 temp então efetuamos R i R i 1,ouseja,oelemento maior que temp migraparaadireitaepassaaserr i ; o antigo valor de R i está guardado em temp. Parai 1 temos: R R R R i 1 i 1 R i 1 0 temp? temp R 1 se R i 1 0 temp:r i 1 R i 1 0 (R 0 migra p/ direita) e depois R 0 temp 3. Para i 2, j i 1 temos:

15 R R R R i 1 i 2 j i 1 temp R 2 se R i 1 1 temp:r i 2 R i 1 1 (R 1 migra p/ direita). A seguir, para i 2, j i 2temos R R R R i 2 i 2 j i 2 temp R 2 se R i 2 0 temp:r i 1 1 R i 2 0 (R 0 migra p/ direita)

16 R R R R i 2 i 1 i 2 j i 2 temp R 2 e depois R 0 temp. R R R R i 2 i 1 i 2 j i 2 temp R 2 Ou seja, se R i 2 temp então efetuamos R i 1 R i 2 : de novo o elemento maior que temp migra para a direita (o valor antigo de R i 1 já havia migrado para R i ). E assim por diante, há uma migração dos elementos maiores que temp de uma posição para a direita. 4. Depois de, no pior caso, comparar temp com

17 R i 1,R i 2,...,R 1,R 0 pode ocorrer uma das duas situações seguintes: a. Ou R j temp para um j entre i 1e0eentãoovalorde temp deve ser colocado em R j 1 e o processo migrar para a direita termina (pois temp que guarda o antigo valor de R i foi colocado no lugar certo); b. Ou depois de verificar que R 0 temp, efetuamosr 1 R 0 e temp deve ser colocado em R A seguir o mesmo laço deve ser executado para a sequência R 0,R 1,...,R i, R i 1 até considerar toda a sequência R 0,R 1,...,R N 2, R N 1.

18 1inteiroi, j, /* variáveis indexadoras */ 2 N; /* número de elementos na sequência */ 3 real R 50 ; /* vetor de até 50 elementos */ 4leiaN; 5parai 0atéN 1 faça 6 leia R i ; 7parai 1atéN 1 faça 8 temp R i ;/*temp guarda R i */ 9 j i 1; /* j i 1,i 2,...,1,0 */ 10 enquanto j 0eR j temp faça /* deslocar R j uma posição p/ direita */ 11 R j 1 R j ; 12 j j 1 ; /*p/esquerda*/ 13 R j 1 temp; /* temp no local adequado */ 14 para i 0atéN 1 faça 15 escreva R i ;

19 Simulação do algoritmo por inserção direta: Vamos supor que a sequência de entrada seja a mesma descrita no exemplo acima, com N 4. linha 10 i temp R j j R j R i temp? sequência resultante não R R ,R , R ,R R ,R , R ,R

20 i linha 11 temp R j j R j R i temp? sequência resultante sim R ,R , R 2 R 1 R ,R sim R ,R , R 1 R 0 R ,R R R ,R , R ,R

21 i temp R j j R j R i temp? sequência resultante sim R ,R , R 3 R 2 R ,R sim R ,R , R 2 R 1 R ,R sim R ,R , R 1 R 0 R ,R R ,R , R R ,R Programa em linguagem C: algoritmo de ordenação

22 por Inserção Direta /* * ORDEINS.C--Exemplo de Ordenacao por Insercao Direta * Problema: dada uma sequencia de N numeros reais (tipo float) * ordena -la em ordem crescente. */ #include stdio.h #define Nmax 100 /* Numero maximo de elementos em R[] */ void main() { int N, /* numero de elementos em R[] */ i, j, IndMin; /* indice do minimo temporario */ float R[Nmax], /* vetor de N elementos */ temp; /* variavel temporaria */ /* * Leitura dos parametros */ printf("\ndigitar o numero de elementos de R[] - "); scanf("%d", &N); printf("\nn %d\n", N); if(n Nmax){ printf("\nnumero maximo de elementos foi excedido\n"); exit(0); } /*end if */ printf("digitar os elementos de R[] a serem ordenados - "); for(i 0; i N-1; i i 1) scanf("%f", &R[i]); printf("\n"); for(i 0; i N-1; i i 1){ printf("r[%d] %f", i, R[i]); } /* end for i */ } /* * Ordenacao dos elementos em R[], em tempo * proporcional a N*N */ /* for(i 1; i N-1; i i 1){ temp R[i]; /* elemento a ser inserido no local adequado */ j i-1; while(j 0 && R[j] temp){ R[j 1] R[j]; /* desloca elemento maior para direita */ j j-1; } /* end while j */ R[j 1] temp; } /* end for i */ /* elemento temp no local adequado */ * Dar resposta final */ printf("\n Elementos de R[], em ordem crescente:\n"); for(i 0; i N-1; i i 1){ printf(" R[%d] %f ", i, R[i]);

23 } /* end for i */ } /* end main */ Exercícios adicionais recomendados: Problema adicional 1: Dados: um inteiro positivo n euma sequência de n números reais ordenados em ordem crescente, inserir um elemento novo mantendo a ordem. Problema adicional 2: Diz-se que uma sequência de n elementos (n par) é balanceada se as seguintes somas são todas iguais: a soma do maior elemento com o menor elemento; a soma do segundo maior elemento com o segundo menor elemento; a soma do terceiro maior elemento com o terceiro menor elemento; e assim por diante. Exemplo: 2,12,3,6,16,15 é balanceada pois Dados n (n par) e uma sequência de n números inteiros, elaborar um programa que verifica se ela é balanceada.

24 Fim