introdução à programação um enfoque orientado a construção de modelos em programas baseados...

Introdução à ProgramaçãoIntrodução à ProgramaçãoUm enfoque orientado a construção de Um enfoque orientado a construção de modelos em programas baseados em modelos em programas baseados em objetosobjetos

Gustavo MottaGustavo MottaDepartamento de Informática - UFPBDepartamento de Informática - UFPB

(C) 2008 Gustavo Motta 2

6. Comandos iterativos e recursão6. Comandos iterativos e recursão

► Comandos iterativos ou de repetiçãoComandos iterativos ou de repetição DefiniçãoDefinição

► Um comando iterativo (também chamado de Um comando iterativo (também chamado de laçolaço) tem um ) tem um

subcomando (o corpo do laço) que é executado subcomando (o corpo do laço) que é executado

repetidamente e uma cláusula que determina quando a repetidamente e uma cláusula que determina quando a

repetição cessarárepetição cessará

Essencial para uma linguagem ser universalEssencial para uma linguagem ser universal

Necessários em muitos modelos e aplicaçõesNecessários em muitos modelos e aplicações► Calcular a média das notas de todos os alunos de uma turmaCalcular a média das notas de todos os alunos de uma turma

► Comparar a seqüência de caracteres em um string que Comparar a seqüência de caracteres em um string que

representa parte de um DNA com outra, representa parte de um DNA com outra, caractere caractere por por

caracterecaractere, , dodo primeiro primeiro atéaté o último o último

► RepetirRepetir a leitura da senha de um usuário a leitura da senha de um usuário enquantoenquanto ela não ela não

estiver corretaestiver correta



► Comandos iterativos ou de repetiçãoComandos iterativos ou de repetição ModalidadesModalidades

► Comandos de iteração indefinidaComandos de iteração indefinida Aqueles nos quais o número de iterações não é determinado Aqueles nos quais o número de iterações não é determinado

previamentepreviamente Depende de uma Depende de uma condição de repetição condição de repetição

► Enquanto não alcançar a última linha do arquivoEnquanto não alcançar a última linha do arquivo, , continue lendo a próxima linha para imprimi-lacontinue lendo a próxima linha para imprimi-la

Em Java, são os comandos Em Java, são os comandos whilewhile e e do-whiledo-while

► Comandos de iteração definidaComandos de iteração definida Aqueles nos quais o número de iterações é sabido Aqueles nos quais o número de iterações é sabido

antecipadamenteantecipadamente Caracterizado pelo uso de uma variável de controle, Caracterizado pelo uso de uma variável de controle,

denominada de denominada de contador do laçocontador do laço► Some os valores de uma seqüência de números, desde a Some os valores de uma seqüência de números, desde a

primeira posição, até a centésimaprimeira posição, até a centésima Em Java, é o comando Em Java, é o comando forfor


► O comando O comando whilewhile►whilewhile ( (expressão-lógicaexpressão-lógica)) subcomando; subcomando;

►whilewhile ( (expressão-lógicaexpressão-lógica) {) { subcomando_1; subcomando_1; subcomando_2; subcomando_2; ... ... subcomando_n; subcomando_n;}}

A avaliação da A avaliação da expressão-lógica expressão-lógica determina a condição determina a condição

de repetição. Caso de repetição. Caso truetrue, o subcomando (ou o bloco de , o subcomando (ou o bloco de

subcomandos) é executado e a condição é reavaliadasubcomandos) é executado e a condição é reavaliada► Enquanto a condição for Enquanto a condição for truetrue, o subcomando é executado, o subcomando é executado

► Quando a condição for Quando a condição for falsefalse, o comando , o comando whilewhile é é

encerrado e o próximo comando é executadoencerrado e o próximo comando é executado



►O comando O comando whilewhile Exemplo: calcular o somatório dos primeiros N Exemplo: calcular o somatório dos primeiros N

números inteiros positivosnúmeros inteiros positivos

intint somatóriosomatório((intint n) { n) { intint soma = 0, proximoInt = 1soma = 0, proximoInt = 1;; whilewhile (proximoInt <= n) { (proximoInt <= n) { soma = soma + proximoInt; soma = soma + proximoInt; proximoInt = proximoInt + 1; proximoInt = proximoInt + 1; } } returnreturn soma; soma;}}......System.out.println(“Somátório de 5: ”+somatório(5));System.out.println(“Somátório de 5: ”+somatório(5));


1

2

Memória

3

n 5

soma 0

proximoInt 1

soma 1

proximoInt 2

soma 3

proximoInt 3

soma 6

proximoInt 4

soma 10

proximoInt 5

soma 15

proximoInt 6

Somatório de 5: 15

1

2

Memória

3


►O comando O comando whilewhile Recomendações de verificaçãoRecomendações de verificação

► Verificar se a condição de repetição Verificar se a condição de repetição inicialinicial do do whilewhile permite a permite a entrada no laço de forma corretaentrada no laço de forma correta Caso a condição inicial seja Caso a condição inicial seja falsefalse, o subcomando ou bloco de , o subcomando ou bloco de

subcomandos do subcomandos do whilewhile não será executado nem mesmo uma vez não será executado nem mesmo uma vez► Caso o valor de Caso o valor de nn seja zero ou negativo, a condição inicial é seja zero ou negativo, a condição inicial é

falsefalse, bloco de subcomandos do , bloco de subcomandos do whilewhile do exemplo anterior do exemplo anterior não é executado nenhuma vez e o resultado do somatório é não é executado nenhuma vez e o resultado do somatório é 00

Nesta versão abaixo do exemplo anterior, o bloco de Nesta versão abaixo do exemplo anterior, o bloco de subcomandos do laço nunca é executado porque a condição subcomandos do laço nunca é executado porque a condição sempre é sempre é falsefalse

intint somatório( somatório(intint n) { n) { intint soma = 0, proximoInt = n + 1soma = 0, proximoInt = n + 1;; whilewhile (proximoInt <= n) { (proximoInt <= n) { soma = soma + proximoInt; soma = soma + proximoInt; proximoInt = proximoInt + 1; proximoInt = proximoInt + 1; } } returnreturn soma; soma;}}


Pode-se usar o próprio comando while para obrigar o usuário a entrar somente com números inteiros positivos

Scanner entrada = new Scanner (System.in);int intPositive = entrada.nextInt();while (intPositive <= 0) { System.out.println("===O numero nao pode ser negativo ou zero===");

intPositive = entrada.nextInt();}

int soma = demowhile.somatório(intPositive);

System.out.println("Somatorio de "+intPositive+": "+soma);



►Verificar se a condição de repetição do Verificar se a condição de repetição do whilewhile permite o permite o encerramento no laço de acordo com a modificação, no encerramento no laço de acordo com a modificação, no bloco de subcomandos do laço, das variáveis usadas na bloco de subcomandos do laço, das variáveis usadas na condiçãocondição

No exemplo anterior, supondo que No exemplo anterior, supondo que proximoInt = 1proximoInt = 1 e que e que n n é é positivo, o subcomando positivo, o subcomando proximoInt = proximoInt + 1; proximoInt = proximoInt + 1; no do no do laço assegura que a condição laço assegura que a condição proximoInt <= n proximoInt <= n será será falsefalse numa dada iteração do numa dada iteração do while while , ou seja, , ou seja, o número de o número de repetições sempre será finito (igual a repetições sempre será finito (igual a nn))

Caso a condição seja sempre Caso a condição seja sempre truetrue, isto é, não possa variar , isto é, não possa variar com a execução sucessiva do bloco de subcomandos do com a execução sucessiva do bloco de subcomandos do whilewhile, então o programa continuará executando para , então o programa continuará executando para sempre, ou seja, sempre, ou seja, o número de repetições será infinitoo número de repetições será infinito


• Por exemplo, o comando while abaixo nunca termina porque a sua condição do sempre será verdadeira (sendo n inicialmente >= 1), ou seja, não varia com a execução dos subcomandos do laço

int somatório(int n) { int soma = 0, proximoInt = 1; while (proximoInt <= n) { soma = soma + proximoInt; proximoInt = proximoInt + 0; } return soma;}

• Embora não termine de forma normal, é possível interromper anormalmente um programa (em loop) com comandos do sistema operacional ou simplesmente desligando o computador, porém os resultados obtidos podem ser indesejáveis



►Quando se tratar de números no comando Quando se tratar de números no comando whilewhile, deve-, deve-se observar a possibilidade da ocorrência de se observar a possibilidade da ocorrência de overflowoverflow

Em números inteiros, o Em números inteiros, o overflowoverflow ocorre quando o resultado ocorre quando o resultado da avaliação de uma expressão aritmética é um número da avaliação de uma expressão aritmética é um número maior (ou menor) que o maior (menor) número que pode maior (ou menor) que o maior (menor) número que pode ser representado num dado tipo inteiroser representado num dado tipo inteiro► Por exemplo, uma variável do tipo Por exemplo, uma variável do tipo bytebyte pode pode

armazenar qualquer valor no intervalo armazenar qualquer valor no intervalo -128-128 até + até +127127

bytebyte contador = 127; contador = 127;contador = (contador = (bytebyte) (contador + 1);) (contador + 1);System.out.println(“Contador: ”+contador);System.out.println(“Contador: ”+contador);

► No exemplo acima, No exemplo acima, -128-128 é o valor impresso é o valor impresso


• Isto porque se o resultado não pode ser armazenado, o valor efetivamente armazenado corresponde ao menor valor armazenável (-128 no caso do tipo byte) adicionado pelo valor que excede o maior valor armazenável menos 1

valorArmazenado = menorInteiro + valorArmazenado = menorInteiro + ((Resultado – maiorInteiro – 1Resultado – maiorInteiro – 1))

•Por exemplo, caso se tente armazenar o valor 200 numa variável do tipo short, o valor efetivamente armazenado será

valorArmazenadovalorArmazenado = = ––128 + (200 – 127 – 1) = 128 + (200 – 127 – 1) = ––5656

•É importante frisar que o nem o compilador, nem a maquina virtual Java, acusa este tipo de erro.

Cabe ao programador tomar cuidado, examinando cuidadosamente os limites máximos e mínimos potencialmente assumidos em variáveis inteiras e sua adequação do tipo escolhido: byte, short, int ou long


► O comando O comando whilewhile Recomendações de verificaçãoRecomendações de verificação

► Quando se tratar de números no comando Quando se tratar de números no comando whilewhile, deve-se , deve-se observar a possibilidade da ocorrência de observar a possibilidade da ocorrência de overflowoverflow Em números de ponto flutuante, o Em números de ponto flutuante, o overflowoverflow também pode também pode

ocorrer, mas nestes casos, a linguagem Java estabelece ocorrer, mas nestes casos, a linguagem Java estabelece valores constantes especiais para designar o infinito positivo valores constantes especiais para designar o infinito positivo e o infinito negativoe o infinito negativo► Por exemplo, ao final da execução do código abaixoPor exemplo, ao final da execução do código abaixo

float valor = float valor = FloatFloat.MAX_VALUE;.MAX_VALUE;valor = valor * 2;valor = valor * 2;System.out.println(“Valor: ” + valor);System.out.println(“Valor: ” + valor);

► No exemplo acima, No exemplo acima, InfinityInfinity é o valor impresso e é o valor impresso e corresponde ao valor da constante corresponde ao valor da constante FloatFloat.POSITIVE_INFINITY .POSITIVE_INFINITY definida na classe definida na classe FloatFloat da da biblioteca de classes de Javabiblioteca de classes de Java




►Quando se tratar de números de ponto flutuante no Quando se tratar de números de ponto flutuante no comando comando whilewhile, deve-se observar a possibilidade da , deve-se observar a possibilidade da ocorrência de ocorrência de underflowunderflow

O O underflowunderflow pode ocorrer quando o tipo ponto flutuante não pode ocorrer quando o tipo ponto flutuante não for capaz de representar um número muito próximo de zero for capaz de representar um número muito próximo de zero ► Por exemplo, ao final da execução do código abaixoPor exemplo, ao final da execução do código abaixo

floatfloat quociente = 1; quociente = 1; whilewhile (quociente > 0) { (quociente > 0) { System.out.println(quociente); System.out.println(quociente); quociente = quociente / 2; quociente = quociente / 2; } }

o valor da variável quociente é zero, embora devesse o valor da variável quociente é zero, embora devesse ser um número muito pequeno, próximo de zero, mas ser um número muito pequeno, próximo de zero, mas não zeronão zero


• O compilador arredonda para zero valores muito próximos de zero que não podem ser representados num dado número de ponto flutuante

•Cabe ao programador tomar todas as precauções necessárias!



►Seja cuidadoso ao usar desigualdades em condições de Seja cuidadoso ao usar desigualdades em condições de controle de repetições no comando whilecontrole de repetições no comando while

► Por exemplo, a execução do código abaixoPor exemplo, a execução do código abaixo

floatfloat saldo = 10; saldo = 10; whilewhile (saldo != 0) { (saldo != 0) { System.out.println(saldo); System.out.println(saldo); saldo = saldo – 0.1f; saldo = saldo – 0.1f; } }

nunca termina, pois devido a imprecisão na nunca termina, pois devido a imprecisão na representação de números decimais (e. g., o valor 0.1) representação de números decimais (e. g., o valor 0.1) em notação de ponto flutuante em base binário, o valor em notação de ponto flutuante em base binário, o valor do saldo passa de um número positivo muito próximo do saldo passa de um número positivo muito próximo de zero para um número negativo também muito de zero para um número negativo também muito próximo a zero, mas sem ser zero, como esperadopróximo a zero, mas sem ser zero, como esperado


• Em casos como este, deve-se evitar o uso de desiguladades. O código anterior pode ser reescrito da forma mais segura abaixo

float saldo = 10;while (saldo >= 0) { System.out.println(saldo); saldo = saldo – 0.1f;}


►O comando O comando whilewhile Comandos de iteração em Java podem ser Comandos de iteração em Java podem ser

encerrados abruptamente, independente da encerrados abruptamente, independente da condição de repetição, com o uso do condição de repetição, com o uso do comandocomando breakbreak► Sempre que um Sempre que um breakbreak é executado dentro de um laço, ele é executado dentro de um laço, ele

força o seu encerramento imediato, seguindo o programa o força o seu encerramento imediato, seguindo o programa o fluxo normal de execução do próximo comando após o laçofluxo normal de execução do próximo comando após o laço

► Por exemplo, o laço abaixoPor exemplo, o laço abaixo

whilewhile ( (truetrue) {) { StringString opcao = entrada.nextLine(); opcao = entrada.nextLine(); ifif (opcao.equals(“s”)) (opcao.equals(“s”)) breakbreak;; System.out.println(opcao); System.out.println(opcao); } }

só termina quando o valor só termina quando o valor opcaoopcao for igual a for igual a ss e o valor de e o valor de opcaoopcao só é impresso se ela for diferente de só é impresso se ela for diferente de ss



► O comando O comando whilewhile Comandos de iteração em Java podem ser Comandos de iteração em Java podem ser

parcialmente interrompidos com o parcialmente interrompidos com o comandocomando continuecontinue► Sempre que um Sempre que um continuecontinue é executado dentro de um laço, é executado dentro de um laço,

ele interrompe a execução dos subcomandos do laço nesta ele interrompe a execução dos subcomandos do laço nesta iteração, a partir do próximo subcomando, voltando para a iteração, a partir do próximo subcomando, voltando para a avaliação da condição de terminação do laçoavaliação da condição de terminação do laço

► Por exemplo, no laço abaixoPor exemplo, no laço abaixo

StringString opcao = opcao = ““aa””;;whilewhile ( (!!opcaoopcao.equals(“.equals(“ss”)”)) {) { opcao = opcao = entrada.nextLineentrada.nextLine();(); ifif ( (opcaoopcao.equals(“.equals(“ss”)”)) ) continuecontinue;; System.out.println(“ System.out.println(“Entre Entre Opção diferente de s”); Opção diferente de s”); }}

o último subcomando só é executado quando a opção é o último subcomando só é executado quando a opção é diferente de s. Caso contrário, o continue força o desvio do diferente de s. Caso contrário, o continue força o desvio do fluxo de execução para a avaliação da condição do laçofluxo de execução para a avaliação da condição do laço




► O comando O comando do-whiledo-whiledodo { { subcomando_1; subcomando_1; subcomando_2; subcomando_2; ... ... subcomando_n; subcomando_n;}} whilewhile ( (expressão-lógicaexpressão-lógica););

A avaliação da A avaliação da expressão-lógicaexpressão-lógica determina a determina a condição de repetição condição de repetição ► Enquanto a condição for Enquanto a condição for truetrue, o bloco de subcomandos é , o bloco de subcomandos é

executadoexecutado

► Quando a condição for Quando a condição for falsefalse, o comando , o comando do-whiledo-while é é

encerrado e o próximo comando é executadoencerrado e o próximo comando é executado

► A diferença em relação ao comando A diferença em relação ao comando whilewhile é que o bloco de é que o bloco de

subcomandos é, necessariamente, executado pelo menos uma subcomandos é, necessariamente, executado pelo menos uma

vezvez


►O comando O comando do-whiledo-while Exemplo: ler a opção do menu de uma aplicação Exemplo: ler a opção do menu de uma aplicação

intint menuCartãoCrédito() { menuCartãoCrédito() { intint opcao = 0opcao = 0;;

ScannerScanner entrada = entrada = new new Scanner(Scanner(System.inSystem.in);); dodo { { System.out.print(“1 - compra | 2 - paga | 3 - ver saldo | “); System.out.print(“1 - compra | 2 - paga | 3 - ver saldo | “); System.out.println(“4 - ver bonus | 5 - encerra: "); System.out.println(“4 - ver bonus | 5 - encerra: "); System.out.print("Sistema de Cartao de Credito. ”); System.out.print("Sistema de Cartao de Credito. ”); System.out.print("Escolha a opcao: "); System.out.print("Escolha a opcao: "); opcao = entrada.nextInt(); opcao = entrada.nextInt();

}} whilewhile (!(opcao > = 1 && opcao <= 5)); (!(opcao > = 1 && opcao <= 5)); returnreturn opcao; opcao;}}



► ContadoresContadores Contadores são variáveis que recebem um valor Contadores são variáveis que recebem um valor

inicial e que são modificadas a cada iteração de inicial e que são modificadas a cada iteração de

comando de repetição de Javacomando de repetição de Java►Contadores são modificados mediante a atribuição do Contadores são modificados mediante a atribuição do

resultado da avaliação de uma expressão aritmética resultado da avaliação de uma expressão aritmética

envolvendo o próprio contadorenvolvendo o próprio contador soma = soma + 1;soma = soma + 1;

fatorial = fatorial * n;fatorial = fatorial * n;

saldo = saldo – 100;saldo = saldo – 100;

quociente = quociente / 2;quociente = quociente / 2;

► Java permite a utilização de Java permite a utilização de operadores especiaisoperadores especiais para para

modificação de variáveis que são contadoresmodificação de variáveis que são contadores



► ContadoresContadores Operador Operador ++++ : quando aplicado a uma variável : quando aplicado a uma variável

numérica, incrementa o valor da variável em umnumérica, incrementa o valor da variável em umsoma++;soma++;

► é o mesmo queé o mesmo que

soma = soma + 1;soma = soma + 1;

► Além de modificar o valor, o operador ++ retorna um valorAlém de modificar o valor, o operador ++ retorna um valor Caso o operador seja aplicado Caso o operador seja aplicado à direitaà direita do operando, o valor do operando, o valor

retornado é igual ao valor da variável antes da aplicação, por retornado é igual ao valor da variável antes da aplicação, por exemploexemplo► intint resultado = 0, contador = 1; resultado = 0, contador = 1;resultado = contador++;resultado = contador++;

► o conteúdo da variável o conteúdo da variável resultadoresultado após a atribuição é após a atribuição é 11 enquanto o conteúdo de enquanto o conteúdo de contadorcontador é é 22

Caso o operador fosse aplicado à esquerdaCaso o operador fosse aplicado à esquerda► resultado = ++contador;resultado = ++contador;

► o conteúdo de ambas as variáveis seria o conteúdo de ambas as variáveis seria 22



► ContadoresContadores Operador Operador ---- : quando aplicado a uma variável : quando aplicado a uma variável

numérica, decrementa o valor da variável em umnumérica, decrementa o valor da variável em umtotal--;total--;

►é o mesmo queé o mesmo que

total = total - 1;total = total - 1;

►Além de modificar o valor, o operador Além de modificar o valor, o operador retorna um valor retorna um valor Caso o operador seja aplicado Caso o operador seja aplicado à direitaà direita do operando, o valor do operando, o valor

retornado é igual ao valor da variável antes da aplicação, retornado é igual ao valor da variável antes da aplicação, por exemplopor exemplo► intint resultado = 0, total = 100; resultado = 0, total = 100;resultado = total--;resultado = total--;

► o conteúdo da variável o conteúdo da variável resultadoresultado após a atribuição é após a atribuição é 100100 enquanto o conteúdo de enquanto o conteúdo de totaltotal é é 9999

Caso o operador fosse aplicado à esquerdaCaso o operador fosse aplicado à esquerda► resultado = --total;resultado = --total;

► o conteúdo de ambas as variáveis seria o conteúdo de ambas as variáveis seria 9999



► ContadoresContadores Operador Operador +=+= : quando aplicado a uma variável : quando aplicado a uma variável

numérica, adiciona, ao valor da variável atribuída, numérica, adiciona, ao valor da variável atribuída, o valor à direita do operandoo valor à direita do operando

saldo += 100;saldo += 100;


saldo = saldo + 100;saldo = saldo + 100;

Operador Operador -=-= : quando aplicado a uma variável : quando aplicado a uma variável numérica, subtrai, do valor da variável atribuída, o numérica, subtrai, do valor da variável atribuída, o valor à direita do operandovalor à direita do operando

saldo -= 50;saldo -= 50;


saldo = saldo - 50;saldo = saldo - 50;



► ContadoresContadores Operador Operador *=*= : quando aplicado a uma variável : quando aplicado a uma variável

numérica, multiplica, o valor da variável atribuída, numérica, multiplica, o valor da variável atribuída, pelo valor à direita do operandopelo valor à direita do operando

fatorial *= n;fatorial *= n;


fatorial = fatorial * n;fatorial = fatorial * n;

Operador Operador /=/= : quando aplicado a uma variável : quando aplicado a uma variável numérica, divide, o valor da variável atribuída, numérica, divide, o valor da variável atribuída, pelo valor à direita do operandopelo valor à direita do operando

quociente /= 100;quociente /= 100;

► o mesmo queo mesmo que

quociente = quociente / 100;quociente = quociente / 100;



►O comando O comando forfor forfor (inicialização; (inicialização; expressão-lógicaexpressão-lógica; atualização); atualização)

subcomando; subcomando;

forfor (inicialização; (inicialização; expressão-lógicaexpressão-lógica; atualização) {; atualização) {

subcomando_1; subcomando_1;

subcomando_2; subcomando_2;

... ...

subcomando_n; subcomando_n;

}}

► inicializaçãoinicialização atribui um valor inicial para o contador do atribui um valor inicial para o contador do forfor

► expressão-lógica expressão-lógica estabelece a condição de repetição do estabelece a condição de repetição do

laçolaço

► atualizaçãoatualização modifica o valor do contador do modifica o valor do contador do forfor




►O comando O comando forfor Exemplo: calcular o fatorial de NExemplo: calcular o fatorial de N

longlong fatorial((intint n) { n) { longlong fat = 1fat = 1;; forfor ( (intint i = 1; i <= n; i++) { i = 1; i <= n; i++) { fat = fat * i; fat = fat * i; } } returnreturn fat; fat;}}......System.out.println(“Fatorial de 5: ”+ fatorial(5));System.out.println(“Fatorial de 5: ”+ fatorial(5));

1

2

Memória

3

n 5

fat 1

Fatorial de 5: 120

i 1i 2

fat 2

i 3

fat 6

i 4i 5

fat 24fat 120


►O comando O comando forfor Outras formas de usoOutras formas de uso

intint contador; contador;forfor (contador = 0; contador < 100; contador++) { (contador = 0; contador < 100; contador++) { System.out.println(contador); System.out.println(contador); }}

for for (contador = 200;contador >= 0; contador -= 10) {(contador = 200;contador >= 0; contador -= 10) { System.out.println(contador); System.out.println(contador);}}

for for ((doubledouble controle = 0;controle < 0; controle += 3.5) { controle = 0;controle < 0; controle += 3.5) { System.out.println(controle); System.out.println(controle);}}



►O comando O comando forfor Outras formas de usoOutras formas de uso doubledouble início = 100; início = 100;

doubledouble fim = 200; fim = 200;

doubledouble incremento = 2.5; incremento = 2.5;

forfor(;;) { (;;) { //executa para sempre//executa para sempre

System.out.println(início);System.out.println(início);

ifif (início >= fim) (início >= fim) breakbreak; ;

início += incremento; início += incremento; } }

for for (contador = 0;contador < 1000; contador+=2) {(contador = 0;contador < 1000; contador+=2) {

System.out.println(contador);System.out.println(contador);

contador = 0; contador = 0;

}}




► RecursãoRecursão Recursão (ou Recursão (ou

recursividade) é uma recursividade) é uma técnica de programação técnica de programação na qual uma computação na qual uma computação é definida em termos é definida em termos dela mesmadela mesma

longlong fatorial(int n) { n) { ifif (n <= 1) { (n <= 1) { returnreturn 1; 1; } } else { else { returnreturn n * n * fatorial(n - 1);; } }}}......System.out.println(“Fatorial System.out.println(“Fatorial de 5: ”+ fatorial(5));de 5: ”+ fatorial(5));

1

2

Memória

3

4

5

n = 5) {n 5

n = 4) {n 4

5 * fatorial(4)5 * 4 * fatorial(3)

n = 3) {

n 3

5 * 4 * 3 * fatorial(2)

n = 2) {

n 2

5 * 4 * 3 * 2 * fatorial(1)

n = 1) {

n 1

5 * 4 * 3 * 2 * 15 * 4 * 3 * 2

n = 2) {

5 * 4 * 6

n = 3) {

5 * 24

n = 4) {

120

n = 4) {

Fatorial de 5: 120

n) {

Drawing Hands (1948), litogravura - M C Escher



► RecursãoRecursão A natureza da recursividadeA natureza da recursividade

►Existem um ou mais casos simples de um problema, Existem um ou mais casos simples de um problema, chamados de chamados de casos de paradacasos de parada, que têm solução trivial, que têm solução trivial

►Os demais casos podem ser solucionados pela Os demais casos podem ser solucionados pela substituição para uma substituição para uma versão reduzida do problemaversão reduzida do problema, , mais próximo do caso de paradamais próximo do caso de parada

►Num dado momento, o problema se reduz a um caso de Num dado momento, o problema se reduz a um caso de parada, que permite a resolução do demais casosparada, que permite a resolução do demais casos

fatorial 1 = 1

fatorial n = n * fatorial n - 1

n * n – 1 * n – 2 * ... * 1

•A recursividade pode ser usada como uma alternativa para

iteração

• Em geral, é uma solução menos eficiente em termos de tempo

e espaço

• Em muitos casos, oferece soluções naturais e simples para

problemas que são difíceis de resolver com comandos iterativos



► RecursãoRecursão Exemplo: Exemplo: torres de Hanóitorres de Hanói

►Objetivo: mover os 5 discos do pino 1 para o pino 3, Objetivo: mover os 5 discos do pino 1 para o pino 3,

obedecendo as seguintes regrasobedecendo as seguintes regras

Apenas um disco pode ser movido por vez, sempre o disco Apenas um disco pode ser movido por vez, sempre o disco

no topo de algum pinono topo de algum pino

Um disco de diâmetro maior jamais pode ser colocado Um disco de diâmetro maior jamais pode ser colocado

sobre um disco com diâmetro menorsobre um disco com diâmetro menor

1 2 3

12345



► RecursãoRecursão Exemplo: torres de HanóiExemplo: torres de Hanói

►SoluçãoSolução Caso de paradaCaso de parada

► Mover um único disco de um pino para outro, por Mover um único disco de um pino para outro, por exemplo, mover o disco 1 para o pino 3exemplo, mover o disco 1 para o pino 3

Versão reduzida do problemaVersão reduzida do problema► 1. Mover 4 discos do pino 1 para o pino 21. Mover 4 discos do pino 1 para o pino 2► 2. Mover o disco 5 para o pino 32. Mover o disco 5 para o pino 3► 3. Mover 4 discos do pino 2 para o pino 33. Mover 4 discos do pino 2 para o pino 3

1 2 3

12345




►SoluçãoSolução Refinamento do passo 1Refinamento do passo 1

► 1. Mover 4 discos do pino 1 para o pino 21. Mover 4 discos do pino 1 para o pino 2

1.1 Mover 3 discos do pino 1 1.1 Mover 3 discos do pino 1 para o pino 3para o pino 3

1.2 Mover o disco 4 do pino 1 1.2 Mover o disco 4 do pino 1 para o pino 2para o pino 2

1.3 Mover 3 discos do pino 3 1.3 Mover 3 discos do pino 3 para o pino 2 para o pino 2

1 2 3

12345




►SoluçãoSolução Refinamento do passo 1.1Refinamento do passo 1.1

► 1.1 Mover 3 discos do pino 1 para o pino 31.1 Mover 3 discos do pino 1 para o pino 3

1.1.1 Mover 2 discos do pino 1 1.1.1 Mover 2 discos do pino 1 para o pino 2para o pino 2

1.1.2 Mover o disco 3 do pino 1.1.2 Mover o disco 3 do pino 1 para o pino 31 para o pino 3

1.1.3 Mover 2 discos do pino 2 1.1.3 Mover 2 discos do pino 2 para o pino 3 para o pino 3

1 2 3

12345




►SoluçãoSolução Refinamento do passo 1.1.1Refinamento do passo 1.1.1

► 1.1.1 Mover 2 discos do pino 1 para o pino 21.1.1 Mover 2 discos do pino 1 para o pino 2

1.1.1 Mover 1 disco do pino 1 1.1.1 Mover 1 disco do pino 1 para o pino 3para o pino 3

1.1.2 Mover o disco 2 do pino 1.1.2 Mover o disco 2 do pino 1 para o pino 21 para o pino 2

1.1.3 Mover 1 disco do pino 3 1.1.3 Mover 1 disco do pino 3 para o pino 2 para o pino 2

1 2 3

12345




►SoluçãoSolução Versão generalizada da soluçãoVersão generalizada da solução

► 1. Caso N > 01. Caso N > 0

1.1 Mover os (N – 1) primeiros discos do pino 1 para o 1.1 Mover os (N – 1) primeiros discos do pino 1 para o pino 2pino 2

1.2 Mover o disco N para o pino final1.2 Mover o disco N para o pino final

1.3 Mover os (N – 1) primeiros discos do pino 2 para o 1.3 Mover os (N – 1) primeiros discos do pino 2 para o pino 3pino 3

1 2 3

12345




►Solução em JavaSolução em Java

voidvoid torresDeHanói( torresDeHanói(intint númeroDeDiscos, númeroDeDiscos, String origem,String destino, String origem,String destino,

String auxiliar) {String auxiliar) {

ifif (númeroDeDiscos > 0) { (númeroDeDiscos > 0) {

torresDeHanói(númeroDeDiscostorresDeHanói(númeroDeDiscos -- 1,origem,auxiliar,destino);1,origem,auxiliar,destino);

System.out.println("MoverSystem.out.println("Mover disco "+númeroDeDiscos+disco "+númeroDeDiscos+ " do "+origem+" para o"+destino);" do "+origem+" para o"+destino);

torresDeHanói(númeroDeDiscostorresDeHanói(númeroDeDiscos -- 1,auxiliar,destino,origem);1,auxiliar,destino,origem);

}}

}}




► Solução em JavaSolução em Java

torresDeHanói(torresDeHanói(3, "p1","p3","p2"3, "p1","p3","p2"))

N = 3Origem = “p1”Destino = “p3”auxiliar = “p2”torresDeHanói(2, , “p1”, “p2”, “p3”))


N = 1Origem = “p1”Destino = “p3”auxiliar = “p2”Mover disco 1 de p1 para p3return

Mover disco 2 de p1 para p2torresDeHanói(1, , “p3”, “p2”, “p1”))returnreturn







introdução à programação um enfoque orientado a construção de modelos em programas baseados...

Documents