08_-_Estruturas_de_Controle_-_Lacos_e_Selecao

Prévia do material em texto

TÉCNICAS DE PROGRAMAÇÃO 1 
INTRODUÇÃO À LING C 
ESTRUTURA DE CONTROLE - 3 
Geiza Maria Hamazaki da Silva 2013.1 
 
Tópicos 
 Para a codificação dos algoritmos é necessário o 
conhecimentos dos comandos na linguagem C. Neste 
conjunto de slides será apresentado um comando 
relacionado com a Construções com Laços 
(Repetição), no qual o teste é realizado após a 
execução do bloco de comandos relacionado com a 
repetição, e o comando relacionado com Seleção. 
Exemplo: máximo divisor comum 
(mdc) 
 Problema: Achar o máximo divisor comum de dois 
números inteiros a e b. 
 
Exemplo: máximo divisor comum 
(mdc) 
 Algoritmo ingênuo 
mdc { 
 leia (a, b); 
 se (a < b) 
 t  a; 
 senão 
 t  b; 
 enquanto (a mod t ≠ 0) ou (b mod t ≠ 0) { 
 t  t - 1; 
 } 
 imprima ("MDC: ” , t); 
} 
Exemplo: máximo divisor comum 
(mdc)- Algoritmo de Euclides 
 Algoritmo do matemático grego Euclides é um dos 
mais antigos conhecidos para o cálculo do mdc é 
apresentado da seguinte forma: 
 Seja r o resto da divisão de a por b então o máximo 
divisor comum de a e b é igual ao máximo divisor 
comum de b e r. 
Exemplo: máximo divisor comum 
(mdc) 
 Algoritmo de Euclides 
mdc-euclides{ 
 leia (a,b); 
 enquanto (b>0) { 
 r  a mod b; 
 a  b; 
 b  r; 
 } 
 imprima ("MDC: ” , a); 
} 
 Seja r o resto da divisão 
de a por b então o 
máximo divisor comum de 
a e b é igual ao máximo 
divisor comum de b e r. 
Exemplo: máximo divisor comum 
(mdc)- Traço 
 Algoritmo de Euclides 
mdc-euclides{ 
 leia (a,b); 
 enquanto (b>0) { 
 r  a mod b; 
 a  b; 
 b  r; 
 } 
 imprima ("MDC: ” , a); 
} 
it r a b 
54.180 13.125 
1 
Exemplo: máximo divisor comum 
(mdc) 
 Algoritmo de Euclides 
mdc-euclides{ 
 leia (a,b); 
 enquanto (b>0) { 
 r  a mod b; 
 a  b; 
 b  r; 
 } 
 imprima ("MDC: ” , a); 
} 
it r a b 
54.180 13.125 
1 1.680 13.125 1.680 
Exemplo: máximo divisor comum 
(mdc) 
 Algoritmo de Euclides 
mdc-euclides{ 
 leia (a,b); 
 enquanto (b>0) { 
 r  a mod b; 
 a  b; 
 b  r; 
 } 
 imprima ("MDC: ” , a); 
} 
it r a b 
54.180 13.125 
1 1.680 13.125 1.680 
2 1.365 1.680 1.365 
Exemplo: máximo divisor comum 
(mdc) 
 Algoritmo de Euclides 
mdc-euclides{ 
 leia (a,b); 
 enquanto (b>0) { 
 r  a mod b; 
 a  b; 
 b  r; 
 } 
 imprima("MDC: ” , a); 
} 
it r a b 
54.180 13.125 
1 1.680 13.125 1.680 
2 1.365 1.680 1.365 
3 315 1.365 315 
Exemplo: máximo divisor comum 
(mdc) 
 Algoritmo de Euclides 
mdc-euclides{ 
 leia (a,b); 
 enquanto (b>0) { 
 r  a mod b; 
 a  b; 
 b  r; 
 } 
 imprima ("MDC: ” , a); 
} 
it r a b 
54.180 13.125 
1 1.680 13.125 1.680 
2 1.365 1.680 1.365 
3 315 1.365 315 
4 105 315 105 
Exemplo: máximo divisor comum 
(mdc) 
 Algoritmo de Euclides 
mdc-euclides{ 
 leia (a,b); 
 enquanto (b>0) { 
 r  a mod b; 
 a  b; 
 b  r; 
 } 
 imprima ("MDC: ” , a); 
} 
it r a b 
54.180 13.125 
1 1.680 13.125 1.680 
2 1.365 1.680 1.365 
3 315 1.365 315 
4 105 315 105 
5 0 105 0 
Exemplo: máximo divisor comum 
(mdc) 
 O algoritmo ingênuo e do Euclides são 
equivalentes. 
 Entretanto se você fizer o traço para os valores 
a=54.180 e b=13.125 serão executadas 13.020 
iterações ((13.125 – 105) repetições do bloco de 
comandos: enquanto (a mod t ≠ 0) ou (b mod t ≠ 0) 
{t  t - 1;}) e no algoritmo de Euclides serão 
executadas 5 interações. 
 Desta forma podemos concluir que o algoritmo de 
Euclides é mais eficiente do que o ingênuo! 
 
Construções com laços: do-while 
 Semelhante ao comando repita <bloco> até 
que <condição> temos em C o comando: 
 
 
 
 
Neste comando o <bloco de comandos> é executado 
pelo menos uma vez porque somente após a sua 
execução a <condição> é testada. 
Vale lembrar que dentro da repetição deve existir uma 
instrução que altera o valor da <condição> 
 
do 
{ 
 bloco de comandos 
} while (condição); 
Construções com laços: do-while 
 
 
 
 Exemplo 
 /* Requisição de valor ao usuário até um número não negativo ser informado */ 
 do 
 { 
 printf("Digite um valor inteiro nao negativo:"); 
 scanf ("%d", &n); 
 } while (n<0); 
 
 
 
do 
{ 
 bloco de comandos 
} while (condição); 
Construções com laços: do-while 
 
 
 
 Exemplo 
 Cálculo do Fatorial 
 
 
 
 
 
do 
{ 
 bloco de comandos 
} while (condição); 
/* Fatorial (versao 3) */ 
#include <stdio.h> 
int main (void) 
{ 
 int i; 
 int n; 
 int f = 1; 
 /* requisita valor do usuário até um número não negativo ser informado */ 
 do 
 { printf("Digite um valor inteiro nao negativo:"); 
 scanf ("%d", &n); 
 } while (n<0); 
 /* calcula fatorial */ 
 for (i = 1; i <= n; i++) 
 f = f * i; 
 printf(" Fatorial = %d\n", f); 
 return 0; 
} 
 
Comando do-while 
 A execução do comando do-while termina 
quando condicao é avaliada em falso (zero) 
ou quando o controle é transferido para fora do 
bloco do do-while por um comando de return 
ou break. 
Construções com laços 
 Interrupção de laços - Comando “break”: 
 termina a execução do comando de laço 
 
 
#include <stdio.h> 
int main (void) 
{ 
 int i; 
 for (i = 0; i < 10; i++) { 
 if (i == 5) 
 break; 
 printf("%d ", i); 
 } 
 printf("fim\n"); 
 return 0; 
} 
 
A saída deste programa, se executado, será: 
 0 1 2 3 4 fim 
Comando do-while 
 A execução do comando continue dentro do 
bloco do do-while pode alterar a execução do 
comando do-while 
Construções com laços 
 Interrupção de laços - Comando “continue”: 
 termina a iteração corrente e passa para a próxima 
 
 
 
 
 
 
 
 
 Na saída o número 5 não foi impresso. 
 
#include <stdio.h> 
 
int main (void) 
{ 
 int i; 
 for (i = 0; i < 10; i++ ) { 
 if (i == 5) continue; 
 printf("%d ", i); 
 } 
 printf("fim\n"); 
 return 0; 
} 
 
gera a saída: 0 1 2 3 4 6 7 8 9 fim 
Construções com laços 
 Interrupção de laços - Comando “continue”: 
 deve-se ter cuidado para criar uma “repetição eterna” 
 
 
/* INCORRETO */ 
#include <stdio.h> 
int main (void) 
{ 
 int i = 0; 
 while (i < 10) 
 { 
 if (i == 5) continue; 
 printf("%d ", i); 
 i++; 
 } 
 printf("fim\n"); 
 return 0; 
} 
cria “repetição eterna” pois i não será mais incrementado quando chegar a 5 
Exemplos 
 Em C, existem duas formas usuais de se escrever um 
laço que “nunca termina” (as vezes chamado de 
“do forever” loop) 
Forma 1: 
 for(;;) { 
 bloco de comandos 
 } 
Forma 2: 
 while (1) { 
 bloco de comandos 
 } 
Exemplos 
 Como apresentado anteriormente, os laços podem 
ser finalizados por um comando de break ou 
return dentro do laço, inclusive o laço for do 
tipo que “nunca termina”. 
Construções com Seleção 
 Além da construção else-if, C provê um comando 
(switch) para selecionar um dentre um conjunto de 
possíveis casos 
 O comando “switch”seleciona uma entre vários casos : 
(“opk” , onde k variade 1 a n, deve ser um inteiro ou 
caractere) 
 
switch ( expr ) 
{ 
 case op1: bloco de comandos 1; break; 
 case op2: bloco de comandos 2; break; 
... 
 default: bloco de comandos default; break; 
} 
Comando switch 
 opk deve ser um número inteiro ou uma constante caractere; 
 Se expr resultar no valor opk os comandos que se seguem 
ao caso opk são executados, até que se encontre um 
break; 
 Se o comando break for omitido, a execução do caso 
continua com os comandos do caso seguinte; 
 Se expr resultar em um valor diferente de opk, mas existir 
um caso default, os comandos que se seguem ao caso 
default são executados, até que se encontre um break; 
 
switch ( expr ) 
{ 
 case op1: bloco de comandos 1; break; 
 case op2: bloco de comandos 2; break; 
... 
 default: bloco de comandos default; break; 
} 
Comando switch 
switch ( expr ){ 
 case op1: 
 ... /* comandos executados se o resultado da 
avaliação de expr == op1 */ 
 break; 
 ... /* comandos executados se o resultado da 
avaliação de expr == op2 */ 
 break; 
 case op3: 
 ... /* comandos executados se o resultado da avaliação 
de expr == op3 */ 
 break; 
 default: 
 ... /* executados se expr for diferente de todos 
*/ 
 break; 
} 
/* calculadora de quatro operações */ 
#include <stdio.h> 
int main (void) 
{ 
 float num1, num2; 
 char op; 
 printf("Digite: numero op numero\n"); 
 scanf ("%f %c %f", &num1, &op, &num2); 
 switch (op) 
 { 
 case '+': printf(" = %f\n", num1+num2); break; 
 case '-': printf(" = %f\n", num1-num2); break; 
 case '*': printf(" = %f\n", num1*num2); break; 
 case '/': printf(" = %f\n", num1/num2); break; 
 default: printf("Operador invalido!\n"); break; 
 } 
 return 0; 
} 
Exemplo 
Comando switch 
switch ( x ){ 
 case 1: printf(“*”); 
 case 2: printf(“**”); 
 case 3: printf(“***”); 
 case 4: printf(“****”); 
} 
 neste exemplo, se o valor de x for igual a 2 então 
nove asteriscos serão impressos, isso acontece pois o 
comando switch transfere o controle para o case 
com expressão igual a 2, a chamada 
printf(“**”) é executada, a seguir a chamada 
printf(“***”) é executada e finalmente a 
chamada printf(“****”) é executada 
Comando switch 
switch ( x ){ 
 case 1: printf(“*”); 
 break; 
 case 2: printf(“**”); 
 break; 
 case 3: printf(“***”); 
 break; 
 case 4: printf(“****”); 
 break; 
} 
 Se deseja terminar a execução do comando switch após 
uma única chamada a printf, deve-se usar o comando 
break. 
31 
Referências 
 W. Celes, R. Cerqueira e J.L. Rangel, Introdução a 
Estruturas de Dados - com técnicas de programação 
em C, Ed. Campus, 2004 
 A. Kelley, A Book on C, Benjamin Cummings, 1995 
 Notas de aulas do curso presencial de Técnicas de 
Programação1- UNIRIO - Desenvolvidos pelas 
professoras: Geiza Maria Hamazaki da Silva e Adriana 
C. F Alvim – primeiro semestre de 2011.