INSTITUTO  FEDERAL  RIO  GRANDE  DO  SUL  Campus  Osório  

Ao final desta Aula:

ü Conhecer o que é a recursividade

ü Compreender a aplicação prática;

ü Estar apto a construir rotinas

recursivas.

Lembre-se

ü Sempre que tiver dúvidas, pergunte.

ü Prestar atenção nas explicações;

ü Utilize as referências para estudar em casa.

ü Chamada a funções

ü Retorno de funções

ü Parâmetros de funções

Caso tenha dificuldades na resolução do exercício, revise o seguinte conteúdo:

O Que é Recursividade?

void triangulo(){

triangulo();}

“Recursividade são rotinas (funções, métodos) que direta ou indiretamente chamam a si mesmas.” (Alves, 2006)

Recursividade  direta  

Recursividade  Indireta  

void ping(){

pong();}void pong(){

ping();}

“A ideia básica de um algoritmo recursivo consiste em diminuir sucessivamente o problema em um problema menor ou mais simples, até que o tamanho ou a simplicidade do problema reduzido permita resolvê-lo de forma direta, sem recorrer a si mesmo.” (Santos, 2005)

ü A definição do problema básico;

ü Uma condição de parada;

ü Uma chamada recursiva.

O Algoritmo recursivo deve sempre conter:  

Crie um algoritmo que utilize recursão onde ao solicitar ao usuário um número inteiro, ele retorne a soma deste com seus antecessores.

5 + 4 + 3 + 2 + 1 + 0 = 15

Entre com um valor: 7 Soma: 28  

Entre com um valor: 5 Soma: 15  

7 + 6 + 5 + 4 + 3 + 2 + 1 + 0 = 28

#include  <stdio.h>    int  soma(int  n)  {  

 if(n==0)      return(0);    else              return(n  +  soma(n-­‐1));  

}  

void  main()  {  int  n;  prinC("Entre  com  um  valor  :  ");  scanf("  %d",  &n);    prinC("Soma:  %d\n",  soma(n));  }    

#include  <stdio.h>    int  soma(int  n)  {  

 if(n==0)      return(0);    else              return(n  +  soma(n-­‐1));  

}  

Função  soma()  está    chamando  ela  mesma!    

#include  <stdio.h>    int  soma(int  n)  {  

         

               soma(n-­‐1)  }  

#include  <stdio.h>    int  soma(int  n)  {  

 if(n==0)      return(0);    else              return(n  +  soma(n-­‐1));  

}  

#include  <stdio.h>    int  soma(int  n)  {  

 if(n==0)      return(0);    else              return(n  +  soma(n-­‐1));  

}  

Resultado... = 15

João deseja comprar uma bicicleta de R$ 350,00 parcelada em 4 vezes. O problema é que a loja cobra juros de 2% ao mês. Quanto custará ao total?

Entre com um valor a vista: 350 Entre com as parcelas: 4 Entre com a taxa de juros: 2 Resultado é: 378.85

Dica:

Parcelas   Valor  +  juros   Total  

1   R$  350,00  +  2%   R$  357,00  

2   R$  357,00  +  2%   R$  364,14  

3   R$  364,14  +  2%   R$  371,42  

4   R$  371,42  +  2%   R$  378,85  

ü Defina um problema básico;

ü Estabeleça a condição de parada;

ü Faça uma chamada recursiva.

Como resolver o problema utilizando a recursividade?  

Qual o problema básico ou simples?

Defina um problema básico  

Parcelas   Valor  +  juros   Total  

1   R$  350,00  +  2%   R$  357,00  

2   R$  357,00  +  2%   R$  364,14  

3   R$  364,14  +  2%   R$  371,42  

4   R$  371,42  +  2%   R$  378,85  

350,00 + (350,00 * 2 )/ 100 357,00 + (357,00 * 2 )/ 100  364,14 + (364,14 * 2 )/ 100 371,42 + (371,42 * 2 )/ 100  

Valor + ((Valor * taxa )/ 100)  

Quando que o problema estará resolvido?

Estabeleça a condição de parada  

Valor + ((Valor * taxa )/ 100)  

Entre com um valor a vista: 350 Entre com as parcelas: 4 Entre com a taxa de juros: 2 Resultado é: 378.85

if(parcelas==0)  {  

   return(0);  }  

Quando calcularmos todas as parcelas!

Qual retorno será desta chamada?

Faça uma chamada recursiva  

Valor + ((Valor * taxa )/ 100)  

return  totalValor(preco,  taxa,  (meses-­‐1))  +  (totalValor(preco,  taxa,(meses-­‐1))  *  (taxa/100));  

Será definida pelo menor problema a ser resolvido!

float  totalValor(float  preco,  float  taxa,  int  meses  )  //387.851256  {          if  (meses==0){                  return  preco;          }else{                      return  totalValor(preco,  taxa,  (meses-­‐1))  +  (totalValor(preco,  taxa,(meses-­‐1))  *  (taxa/100));          }  }  

int  main(int  argc,  const  char  *  argv[])  {    prin]("Resultado  é  %f",  totalValor(350,2,3));  

       return  0;  }  

ü A recursividade é uma técnica opcional;

ü Facilita a codificação de problemas complexos;

ü Pode tornar-se lenta, dependendo da quantidade de chamadas.

Resumo  

ü Crie um algoritmo recursivo para calcular o

fatorial de um número.

ü Crie um algoritmo recursivo para resolver o

problema das torres de Hanoi.

Alves, Carlos E. Ensino de programação recursiva em Ciência da Computação. Revista Integração. p. 115-133. 2006. Disponível

em ftp://ftp.usjt.br/pub/revint/115_45.pdf Acesso em 11/06/2015.

Deitel, Harvey; Paul Deitel; C - Como Programar. 6a Edição. Editora Pearson, 2011.

Eric S. Roberts. Art and Science of C, The: A Library Based Introduction to Computer Science. Editora Prentice Hall, 1995 . ISBN:

9780201543223.

FEOFILOFF, PAULO. Algoritmos em Linguagem C. Editora Campus/Elsevier. 2008-2009. ISBN: 978-85-352-3249-3.

Roberts, Eric S. ; Programming Abstractions in C: A Second Course in Computer Science. Editora Addison-Wesley, 1997. ISBN:

9780201545418

Santos, Wellington L. Algoritmos e Estrutura de Dados II. Disponível em<

https://www.ic.unicamp.br/~ripolito/peds/mc102z/material/Recursividade.PDF> Acesso em 11/06/2015.

SOORIAMURTHI, R. Problems in Comprehending Recursion and Suggested Solutions. Proc. of the 6th Annual Conference on

Innovation and Technology in Computer Science Education (ITiCSE). Canterbury, UK, junho de 2001, p. 25-8.

Referências