5 - Estruturas de Controle do Fluxo de Execução

Prévia do material em texto

Algoritmos
Prof. Hilton Cardoso Marins Junior
hiltonmarins@gmail.com
ESTRUTURAS DE CONTROLE DO FLUXO DE 
EXECUÇÃO
Estruturas de Controle de Fluxo de Execução
Esta é uma das partes mais importantes do nosso curso: 
Determinar a sequência em que os comandos deverão ser
executados.
Prever corretamente as possibilidades( alternativas) de execução.
Implementar corretamente as operações repetitivas.
Sequência - Fluxograma
C1C1
C2
C3
Cn
Sequência - Portugol
inicio
Comando-1;
Comando-2;
.
.
.
Comando-n;
fim.
Este recuo para a direita dos comandos internos é chamado de Identação e 
serve para mostrar visualmente a relação de hierarquia entre os comandos.
Sequência - C
{
Comando-1;
Comando-2;
.
.
.
Comando-n;
}
As chaves indicam início e fim de um bloco de comandos.
Alternativa Simples - Fluxograma
Os comandos (c1, c2, …, cn) serão executados somente se a condição
for verdadeira.
condição
c-1
V
F
c-2
c-n
Alternativa Simples - Portugol
se <condição> então
c1;
c2;
…
cn;
fim-se;
Alternativa Simples - C
if (<condição>) {
c1;
c2;
…
cn;
}
Qual a saída produzida pelo algoritmo abaixo, supondo 
que foi fornecido como dado de entrada o número 5.
inicio
leia(n)
n 
> 
0
Imprima (“Numero positivo”)
fim
V
F
1
Qual a saída produzida pelo algoritmo abaixo, supondo 
que foi fornecido como dado de entrada o número 5.
inicio
leia(n)
n 
> 
0
Imprima (“Numero positivo”)
fim
V
F
1
Qual a saída produzida pelo algoritmos abaixo, supondo 
que foi fornecido como dado de entrada o número -5.
inicio
leia(n)
n 
> 
0
Imprima (“Numero positivo”)
fim
V
F
2
Qual a saída produzida pelo algoritmos abaixo, supondo 
que foi fornecido como dado de entrada o número -5.
inicio
leia(n)
n 
> 
0
Imprima (“Numero positivo”)
fim
V
F
2
Qual a saída produzida pelo algoritmos abaixo, supondo 
que foi fornecido como dado de entrada o número 0.
inicio
leia(n)
n 
> 
0
Imprima (“Numero positivo”)
fim
V
F
3
Qual a saída produzida pelo algoritmos abaixo, supondo 
que foi fornecido como dado de entrada o número 0.
inicio
leia(n)
n 
> 
0
Imprima (“Numero positivo”)
fim
V
F
3
Representação do algoritmo anterior em Portugol.
inicio
inteiro: n
leia(n)
se (n > 0) então
imprima(“Numero positivo”)
fim-se;
fim.
inicio
leia(n)
n 
> 
0
Imprima (“Numero positivo”)
fim
V
F
Implementação do algoritmo anterior em C.
main(){
int n;
printf(“\nInforme um numero:”);
scanf(“%d”, &n);
if (n > 0){
printf(“\nNumero positivo”);
}
}
Alternativa Composta - Fluxograma
Os comandos (c1, c2, …, cn) serão executados somente se a condição
for verdadeira e os comandos (c'1, c'2, …, c'n) serão executados
somente se a condição for falsa.
condiçãoF
c1
V
c2
cn
c'1
c'2
c'n
Alternativa Composta - Portugol
se <condição> então
c1;
c2;
…
cn;
senão
c'1;
c'2;
…
c'n;
fim-se;
Alternativa Composta - C
if (condição) {
c1;
c2;
…
cn;
}else{
c'1;
c'2;
…
c'n;
}
O programa abaixo lê um número e verifica se é positivo, 
negativo ou nulo.
main(){
int n;
printf(“\nInforme um numero:”);
scanf(“%d”, &n);
if (n > 0){
printf(“\nNumero positivo”);
}else{
if (n < 0){
printf(“\nNumero negativo”);
}else{
printf(“\nNumero nulo”);
}
}
}
Verdadeiro e Falso na Linguagem C
Em C um valor diferente de zero é considerado verdadeiro e igual a zero 
falso. Uma instrução if não fica restrita expressões envolvendo os
operadores lógicos e relacionais. O programa simplesmente precisa chegar a 
um valor zero (falso) e não zero(verdadeiro). 
Observe os dois trechos de programa abaixo e responda: quais instruções
serão executadas, c1 ou c2?
...
int x = 10;
if (x){
c1;
}else{
c2;
}
...
...
int x = 10;
if (x-10){
c1;
}else{
c2;
}
...
Verdadeiro e Falso na Linguagem C
Em C um valor diferente de zero é considerado verdadeiro e igual a zero 
falso. Uma instrução if não fica restrita expressões envolvendo os
operadores lógicos e relacionais. O programa simplesmente precisa chegar a 
um valor zero (falso) e não zero(verdadeiro). 
Observe os dois trechos de programa abaixo e responda: quais instruções
serão executadas, c1 ou c2?
...
int x = 10;
if (x){
c1;
}else{
c2;
}
...
...
int x = 10;
if (x-10){
c1;
}else{
c2;
}
...
Alternativa Múltipla - Fluxograma
O resultado da expressão ordinal será comparado com cada um 
dos casos e somente os comandos relacionados a um 
determinado caso, serão executados.
Expressão
ordinal
comandos-1 comandos-2 comandos-n
caso1 caso2 caso n
Qualquer expressão que
tenha como resultado
um inteiro ou char
Alternativa Múltipla - Portugol
escolha (expressão ordinal) 
caso1: instrucoes;
caso2: instrucoes;
...
senão: instrucoes;
fim-escolha;
Alternativa Múltipla - C
switch (<expressão ordinal>) 
{
case constante1: instrucoes;
break;
case constante2: instrucoes;
break;
...
default: instrucoes;
}
Cada case pode ter várias instruções. Estas instruções não devem estar
entre chaves. Se um caso for igual ao valor da expressão a execução começa
nele. O comando break causa a saida do comando switch. Se nao existir um 
comando break seguindo as instruções de um caso, o programa segue 
executando as instruções dos casos seguintes. Se nenhum caso for satisfeito
a execução comeca no default, que por sua vez é opcional.
Programa que calcula o mês por extenso.
main(){
int mes;
printf("\n Digite o numero do mes: ");
scanf("%d", &mes);
switch (mes){
case 1: printf(“\nJaneiro.”);
break;
case 2: printf(“\nFevereiro.”);
break;
...
case 12: printf(“\nDezembro.”);
break;
default: printf("Mes inválido !!!");
}
}
Repetição Com Teste no Início
Os comandos internos ao comando de repetição serão executados repetidas
vezes, enquanto a condição for verdadeira.
V
F enquanto (condição) façacomandos;
fim-enquanto;
while (condição) {
comandos;
}
comandos
condição
(Fluxograma)
(portugol)
(C)
Repetição Com Teste no Final
Os comandos internos ao comando de repetição serão executados repetidas
vezes, enquanto a condição for verdadeira.
faça
comandos;
enquanto (condição);
do{
comandos;
}while (condição);
V
F
comandos
condição
(Fluxograma)
(portugol)
(C)
Repetição Com Variável de Controle - Fluxograma
V
F
variavel = valor inicial
comandos
Incrementa/descrementa
a variavel
variavel
<=
valor final
A repetição é controlada pela
variável de controle.
Esta variável recebe um valor 
inicial e a cada repetição este
valor é alterado.
Enquanto a condição for 
verdadeira haverá repetições.
Repetição Com Variável de Controle – Portugol
para vc = vi até vf passo p faça
comandos;
fim-para
vc: variável de controle
vi: valor inicial da vc
vf: valor final da vc
p: incremento/decremento da vc
Repetição Com Variável de Controle – C
for (inicialização; condição; incremento/decremento){
comandos;
}
A inicialização é sempre executada uma única vez antes da primeira
repetição.
A condição é avaliada a cada repetição. Se for falsa, a repetição é finalizada, 
caso contrário uma nova repetição ocorrerá.
O incremento/decremento define a maneira como a variável de controle
será alterada a cada repetição. Serve para que a variável de controle chegue a 
um valor que torne a condição falsa, ou seja, que a repetição chegue ao fim. 
É realizado ao final de cada repetição e antes da próxima repetição.
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i<= 5){
mostra(i);
i = i + 1;
}
}
i
1
saída
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
saída
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
saída
1
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
saída
1
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
saída
1
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
saída
1
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
saída
1
2
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
saída
1
2
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
saída
1
2
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
saída
1
2
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
saída
1
2
3
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
saída
1
2
3
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
saída
1
2
3
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
saída
1
2
3
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
saída
1
2
3
4
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
saída
1
2
3
4
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
saída
1
2
3
4
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
saída
1
2
3
4
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
saída
1
2
3
4
5
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
6
saída
1
2
3
4
5
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
6
saída
1
2
3
4
5
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
6
saída
1
2
3
4
5
Mostrar na tela os números inteiros de 1 até 5.
inicio
i = 1;
enquanto (i <= 5){
mostra(i);
i = i + 1;
}
}
i
1
2
3
4
5
6
saída
1
2
3
4
5
Mostrar na tela os números inteiros de 1 até 5.
Implementamos, em C, o algoritmo anterior de três formas 
diferentes.
main(){
int i = 1;
while (i <= 5){
printf(“%d”, i);
i = i + 1;
}
}
main(){
int i = 1;
do{
printf(“%d”, i);
i = i + 1;
}while (i <= 5);
}
main(){
int i;
for (i=1; i <= 5, i=i+1){
printf(“%d”, i);
}
}
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
saída
0
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
saída
0
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
saída
0
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
saída
0
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
saída
0
1
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
saída
0
1
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
saída
0
1
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
saída
0
1
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
saída
0
1
4
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
-3
saída
0
1
4
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
-3
saída
0
1
4
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
-3
saída
0
1
4
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
i
0
-1
-2
-3
saída
0
1
4
9
Quais as saídas produzidas?
inicio
i = 0;
enquanto (i < 20){
mostra(i*i);
i = i-1;
}
mostra(“Ufa! Acabou!”);
}
Este algoritmo foi mal elaborado pois a condição nunca se tornará falsa para que 
as repetições sejam finalizadas e o fluxo de execução possa continuar 
normalmente. Dizemos que o algoritmo está preso em um LOOP.
i
0
-1
-2
-3
-4
.
.
.
saída
0
1
4
9
Atenção
Qual o 1º e o último valor impresso?
int x = 99;
while (x <= 99){
x = x + 1;
printf(“%d”, x);
}
Qual o 1º e o último valor impresso?
int x = 99;
while (x <= 99){
x = x + 1;
printf(“%d”, x);
}
Primeiro: 100
Último..: 100
Quais as saídas produzidas?
Versão com while
int x = 100;
while (x < 10){
printf(“%d”, x);
x = x + 1;
}
Quais as saídas produzidas?
Versão com while
int x = 100;
while (x < 10){
printf(“%d”, x);
x = x + 1;
}
x
100
Quais as saídas produzidas?
Versão com while
int x = 100;
while (x < 10){
printf(“%d”, x);
x = x + 1;
}
x100
Quais as saídas produzidas?
Versão com while
int x = 100;
while (x < 10){
printf(“%d”, x);
x = x + 1;
}
Não haverá saída pois os comandos internos ao while nunca 
serão executados.
x
100
Quais as saídas produzidas?
Versão com do … while
int x = 100;
do{
printf(“%d”, x);
x = x + 1;
}while (x < 10);
Quais as saídas produzidas?
Versão com do … while
int x = 100;
do{
printf(“%d”, x);
x = x + 1;
}while (x < 10);
x
100
Quais as saídas produzidas?
Versão com do … while
int x = 100;
do{
printf(“%d”, x);
x = x + 1;
}while (x < 10);
x
100
saída
100
Quais as saídas produzidas?
Versão com do … while
int x = 100;
do{
printf(“%d”, x);
x = x + 1;
}while (x < 10);
x
100
101
saída
100
Quais as saídas produzidas?
Versão com do … while
int x = 100;
do{
printf(“%d”, x);
x = x + 1;
}while (x < 10);
A diferença da versão com do...while, para o programa anterior, é que 
ocorrerá pelo menos uma repetição.
x
100
101
saída
100
Quais as saídas produzidas pelo trecho abaixo?
for (int i=1; i <=10; i++){
printf(“\n%d.”, i);
}
Quais as saídas produzidas pelo trecho abaixo?
for (int i=1; i <=10; i++){
printf(“\n%d.”, i);
}
10.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
Imprimir os 10 primeiros múltiplos de 5
for (int i=1; i <=10; i++){
printf(“\n%d”, i*5);
}
Imprimir os 10 primeiros múltiplos de 5 em ordem inversa
for (int i=10; i >=1; i--){
printf(“\n%d”, i*5);
}
Aninhamento de comandos
main(){
int linha,coluna;
for (linha=1;linha<=5;linha++){
for (coluna=1;coluna<=5;coluna++){
printf("\t[%d,%d]",linha, coluna);
}
printf("\n");
}
}
A saída será a seguinte:
[1,1] [1,2] [1,3] [1,4] [1,5]
[2,1] [2,2] [2,3] [2,4] [2,5]
[3,1] [3,2] [3,3] [3,4] [3,5]
[4,1] [4,2] [4,3] [4,4] [4,5]
[5,1] [5,2] [5,3] [5,4] [5,5]
Causa um avanço de tabulação
Causa uma mudança de linha
Quais as Saídas Produzidas?
i = 0;
while (i <= 675){
printf(“%d”, i);
i = i + 2;
}
Quais as Saídas Produzidas?
i = 0;
while (i <= 675){
printf(“%d”, i);
i = i + 2;
}
0, 2, 4, 6, … , 672, 674
Quais as Saídas Produzidas?
x = 99;
while (x <= 99){
x = x + 1;
printf(“%d”, x);
}
Quais as Saídas Produzidas?
x = 99;
while (x <= 99){
x = x + 1;
printf(“%d”, x);
}
100