ALGORITMOS, ESTRUTURAS DE DADOS

Professores: PhD. Alfredo Pena Ricardo e MSc. Yudith Zamora Castell

Lubango 2020

Algoritmos sequenciais de decisão e cíclicos

2020

1
 1. Algoritmos sequenciais
Problema:
Implementar um algoritmo que faz o carregamento de dois números inteiros pelo teclado e
mostrar na tela a soma e seu produto.

Análise

Variáveis de entrada: número1 e número2,

Variáveis de saída: soma e produto
Processos: cálculo da soma e produto
Decisões: não,
Algoritmo

Como pode-se observar o algoritmo segue uma estrutura sequencial

Código fonte:

pakage SomaProduto;
import java.util.*;

public class SomaProduto {

public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
int num1,num2,soma,produto; //declaração da variaveis
System.out.println("Ingresse o primeiro valor:");
num1=teclado.nextInt();
System.out.println("Ingresse o segundo valor");
num2=teclado.nextInt();
soma=num1 + num2;
produto=num1 * num2;
System.out.println("a soma dos dois valores é:" + soma);
System.out.println("o produto dos dois valores é:" + produto);
}
}
Pegue o código e execute no NetBeans

2. Algoritmos condicionais simples e compostos

2
Esquema geral dum algoritmo condicional simples, existe um losango o que indica uma estrutura
condicional, onde temos que tomas uma decisão

Problema:
Desenvolva um algoritmo para resolver o problema a seguir.
Ingressar o salário de uma pessoa, se o mesmo supera os 30000 Kz, mostrar uma mensagem na tela
indicando que deve pagar impostos
Análise
Variáveis de entrada: salário
Variáveis de saída: não
Decisões: sim, mostrar uma SMS se o salário introduzido for superior ou igual a 30000Kz

Código fonte
pakage salario;
import java.util.*;
public class Salario {
public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
float salário;
System.out.println("Ingresse o salário:");
salário=teclado.nextFloat();
if (salário>30000) {
System.out.println("Esta pessoa deve pagar impostos");
}
}
}

2.1 Algoritmo condicional composto.

Representação gráfica do algoritmo geral:

3
 Problema:
Escrever um algoritmo que permita ingressar dois números distintos pelo teclado e apresente na tela o
maior deles. Estamos em presença dum algoritmo CONDICIONAL COMPOSTO

Algoritmo:

Código fonte:
pakage números;
import java.util.*;
public class Numeros {
public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
int num1,num2;
System.out.println("Ingresse primeiro valor:");
num1=teclado.nextInt();
System.out.println("Ingresse segundo valor:");
num2=teclado.nextInt();
if (num1>num2) { // condição se
System.out.println(num1);
} else { // condição se não
System.out.println(num2);
}
}
}

Teste este código anterior no NetBeans

2.2 Algoritmos condicionais que utilizam operadores lógicos (&& significa (e), || significa (ou)).

Escreva um algoritmo que permita a leitura de três números distintos e mostre o maior.

Algoritmo:

4
Código fonte:

pakage maior;
import java.util.*;
public class Maior {
public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
int num1,num2,num3;
System.out.print("Ingresse o primeiro valor:");
num1=teclado.nextInt();
System.out.print("Ingresse segundo valor:");
num2=teclado.nextInt();
System.out.print("Ingresse o terceiro valor:");
num3=teclado.nextInt();
if (num1>num2 && num1>num3) {
System.out.print(num1);
} else {
if (num2>num3) {
System.out.print(num2);
}else {
System.out.print(num3);
}
}
}
}
Teste este código no NerBeans

2.2.1 Algoritmos condicionais que utilizam operadores lógicos (&& significa (e), || significa (ou)).

Escrever um algoritmo que permita que solicitar uma data (día, mês e ano) e mostrar uma mensagem se a mesma
corresponde ao primeiro trimestre do ano (janeiro, fevereiro ou março). Carregar pelo teclado o valor numérico do
día, mês e o ano.

5
Algoritmo:

Neste algoritmo a condição o que diz é que se o mês é 1, ou o mês é 2 ou o mês é 3, então a condição é verdadeira,
se qualquer de aqueles três for verdadeira, então a condição geral também é verdadeira, a diferença com ocaso 2.2
onde ambas tem que ser verdadeiras para considerar a condição geral verdadeira, caso contrário seria falsa.

3. Algoritmos recursivos
3.1 algoritmo recursivo while

Agora temos que apontar que em todos os casos anteriores as variáveis de entrada sempre são entre um e três
valores, facto que simplifica o algoritmo em tempo de execução, mas se em lugar de esta pequena quantidade de
número for necessário introduzir uma elevada quantidade de números, por exemplo 10000 valores de entrada ou
ainda muito menos do que isto, converteria no algoritmo muito ineficiente além de ser cansativo para o utilizador,
por tal razão quando há muitas operações repetitivas, então é mais apropriado utilizar um algoritmo cíclico.

Reapresentação gráfica do algoritmo recursivo while

Funcionamento: primeiro verifica-se a condição, se a mesma resulta verdadeira se executam as operações indicadas
pelo ramo do Verdadeiro. No caso que a condição seja falsa continua pelo ramo do Falso e sai da estrutura repetitiva
para continuar com a execução do algoritmo. O bloco se repete ENQUANTO QUE a condição for Verdadeira.

6
Problema:
Escreva um algoritmo que perita solicitar ingressar um valor positivo e apresente todos os números desde 1 até o
valor ingressado, em ordem crescente. Exemplo: Se ingressamos 30 se deve mostrar os números de 1 até 30.

Algoritmo:

Código fonte:

Ppakage intervaloNumero;
import java.util.*;
public class IntervaloNumero {
public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
int n,x;
System.out.println("Ingresse um valor :");
n=teclado.nextInt();
x=1;
while (x<=n) {
System.out.println(x);
System.out.println(" - ");
x = x + 1;
}
}
}
Teste o código anterior com o NetBeans

O algoritmo anterior, após de cada ciclo, volta avaliar a condição e este facto faz diminuir a eficiência do mesmo em
tempo de execução, pelo que quando são muitos dados, é preferível procurar um outro algoritmo que evite es
proceder para conseguir melhorar a eficiência. (Ver documento onde se trata a introdução ao analise de algoritmos)

3.2 Algoritmo do while (faz enquanto que)

O algoritmo do while é outra estrutura recursiva, a qual executa-se pelo menos uma vez seu bloco repetitivo, a
diferença de while ou do algoritmo for que poderiam não executar o bloco dependendo da condição.

Representação gráfica geral do algoritmo:

7
Problema :

Desenvolver um algoritmo que permita ingressar o peso (em kilogramas) das peças produzidas por uma fábrica. O
processo termina quando ingressamos o valor 0. Deve-se informar as seguintes mensagens:
a). Quantas peças tem um peso entre 9,8 Kg. e 10,2 Kg.?, quantas com mais de 10,2 Kg.? e quantas com menos de 9,8
Kg.?
b) A quantidade total de peças processadas

Algoritmo :

8
Código fonte_

package peças;
import java.util.*;
public class Peças {
public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
int quant1,quant2,quant3,soma;
float peso;
quant1=0;
quant2=0;
quant3=0;
do {
System.out.print("Ingresse o peso da peca (0 pera finalizar):");
peso=teclado.nextFloat();
if (peso>10.2) {
quant1++;
} else {
if (peso>=9.8) {
quant2++;
} else {
if (peso>0) {
quant3++;
}
}
}
} while(peso!=0);
soma=quant1+quant2+quant3;
System.out.println("Pecas aptas:" + quant2);
System.out.print("Pecas com um peso superior a 10.2:" + quant1);
System.out.print("Pecas com um peso inferior a 9.8:"+ quant3);
}
}
Teste o código anterior com o NetBeans

4. Esquema geral do algoritmo recursivo for

ou

Problema :

Desenvolva um algoritmo que solicite ingressar 10 valores e mostre posteriormente a soma dos valores ingressados
e a média. (Estrutura for).

Análise:

9
Variáveis de entrada: valor,
Variáveis de saída: soma, média
A soma está escrita como frequência acumulada porque vai-se somando o valor que fosse introduzindo
soma=soma+valor;
Processos: cálculo da soma e a média
Decisões: continuar a execução até que f for menor ou igual a 10, caso contrário terminar ciclo e continuar o fluxo
Variáveis de saída: soma e média
Algoritmo:

Código fonte:

package estruturaRepetitivaFor1;
import java.util.*;

public class EstruturaRepetitivaFor1 { // classe

public static void main(String[] args) { // método main
Scanner teclado=new Scanner(System.in); //invocação da classe Scanner
int soma, f ,valor,média; // declaração de variaveis, f é o contador que vai contar quanta vezes se repete o ciclo
soma=0;
for(f=1;f<=10;f++) { // início do ciclo for
System.out.println("Ingresse um valor:");
valor=teclado.nextInt();
soma=soma+valor;
} // fim do ciclo for
System.out.println("a soma e:");
System.out.println(soma);
média=soma/10;

10
 System.out.println("a média e:");
System.out.println(média);
}
}
Pegue o código anterior e execute-o no NetBeans e observe o resultado

Problema :
Escrever uma classe que leia 10 números inteiros elo teclado e logo mostre quantos valores ingressados foram
múltiplos de 3 e quantos de 5, devemos ter em conta que há números que são múltiplos de 3 e de 5

Análise:
Variáveis de entrada: valor,
Variáveis de saída: múltiplos de 3, múltiplos de 5, Frequências acumuladas: 2, que são mul3=mult3+1 ; mul5=mult5+1, as mesmas
devem ser inicializadas em zero
Processos: cálculo da soma das 2 frequências acumuladas
Decisões: Sim, se o resto da divisão inteira por 3 é Zero então é múltiplo de 3 e soma 1 para a frequência acumulada mul3, se o resto
da divisão inteira por 5 é zero, soma 1 na frequência acumulada mul5 e repetir o ciclo quando f menor ou igual a 10, caso contrário
sair do ciclo e continuar o fluxo, neste caso mostrando o resultado e logo terminar.
Algoritmo:

Código fonte
package estruturaRepetitivaFor2;
import java.util.*;
public class EstruturaRepetitivaFor2 {
public static void main(String[] args) {
Scanner teclado=new Scanner(System.in);
int mul3,mul5,valor,f;
mul3=0; // isto significa que há que inicializar esta variável pois quando náo se digitou
//nehum número ele tem valor Zero,

11
 mul5=0;
for(f=1;f<=10;f++) {
System.out.print("ingresse un valor:");
valor=teclado.nextInt();
if (valor%3==0) {
mul3=mul3+1;
}
if (valor%5==0) {
mul5=mul5+1;
}
}
System.out.print("Quantidade de valores ingressados múltiplos de 3:");
System.out.println(mul3);
System.out.print("Quantidade de valores ingressados múltiplos de 5:");
System.out.print(mul5);
}
}

Pegue o código anterior e execute-o no NetBeans e observe o resultado

Problema:
Escrever uma Classe que leia n números inteiros pelo teclado e calcule a quantidade de valores maiores o iguais a
1000. Este tipo de problemas se pode resolver utilizando um algoritmo recursivo for. O primeiro que se faz é carregar
uma variável que indique a quantidade de valores a ingressar, a mesma se carrega antes de entrar na estrutura
repetitiva for. A estrutura for permite que o valor inicial ou final dependa de uma variável carregada previamente por
teclado, por exemplo o próprio usuário poderá dizer quantas vezes vai calcular.
Algoritmo:

Código fonte:
package estruturaRepetitivaFor3
import java.util.*;
public class EstruturaRepetitivaFor3 {
public static void main(String[] args) {

12
 Scanner teclado=new Scanner(System.in);
int quantidade,n,f,valor;
quantidade=0;
System.out.println("Quantos valores ingressará:");
n=teclado.nextInt();
for(f=1;f<=n;f++) {
System.out.println("Ingresse o valor:");
valor=teclado.nextInt();
if (valor>=1000) {
quantidade=quantidade+1;
}
}
System.out.println("a quantidade de valores ingressados maiores ou iguais a 1000 são:");
System.out.print(quantidade);
}
}
Pegue o código anterior e execute-o no NetBeans e observe o resultado

Problema para resolver:

Se deseja criar um aplicativo que leia as notas de n estudantes e mostre quantos tem notas maiores ou iguais a
12(Aptos) e quantos menores a 12 valores(Reprovados).

a) Faz a análise do algoritmo para resolver o problema

b) Desenhe o algoritmo em forma de fluxograma
c) Escreva o código fonte do algoritmo descrito

13