Compilação – Material sobre recursividade

Recursividade
Na linguagem C, assim como em muitas outras linguagens de programação,
uma função pode chamar a si própria. Uma função assim é chamada função
recursiva. Todo cuidado é pouco ao se fazer funções recursivas. A primeira
coisa a se providenciar é um critério de parada. Este vai determinar quando a
função deverá parar de chamar a si mesma. Isto impede que a função se chame
infinitas vezes.
Uma função que calcule o fatorial de um número inteiro n é um bom exemplo
de uma função recursiva:
#include <stdio.h>
int fat(int n)
{
if (n)
return n*fat(n-1)
else return 1;
}
int main()
{
int n;
printf("\n\nDigite um valor para n: ");
scanf("%d", &n);
printf("\nO fatorial de %d e' %d", n, fat(n));
return 0;
}
Note que, enquanto n não for igual a 0, a função fat chama a si mesma, cada
vez com um valor menor. n=0 é critério de parada para esta função.
Há certos algoritmos que são mais eficientes quando feitos de maneira
recursiva, mas a recursividade é algo a ser evitado sempre que possível, pois,
se usada incorretamente, tende a consumir muita memória e ser lenta. Lembrese que memória é consumida cada vez que o computador faz uma chamada a
uma função. Com funções recursivas a memória do computador pode se esgotar
rapidamente.
Outro Exemplo:
Crie um programa em C que peça um número inteiro ao usuário e
retorne a soma de todos os números de 1 até o número que o usuário
introduziu ou seja: 1 + 2 + 3 + ... + n
Utilize recursividade.
Vamos criar uma função soma(int n).
Se n=5, essa função deve retornar: soma(5) = 5 + 4 + 3 + 2 + 1
Se n=4, essa função deve retornar: soma(4) = 4 + 3 + 2 + 1
Se n=3, essa função deve retornar: soma(3) = 3 + 2 + 1
E assim por diante. Porém, para fazermos uso da brilhante idéia matemática
da recursividade, temos que notar padrões.
Veja que:
soma(5) = 5 + 4 + 3 + 2 +1 = 5 + soma(4)
O mesmo para:
soma(4) = 4 + 3 + 2 + 1 = 4 + soma(3)
Ou seja, temos a fórmula geral:
soma(n) = n + soma(n-1)
Concorda?
Ou seja:
soma(n) = n + soma(n-1) = n + (n-1) + soma(n-2) = n + (n-1) + (n-2) +
soma(n-3)...
E onde essa soma para? Para quando o último elemento dessa soma for 1.
Então:
soma(n) = n +(n-1) + (n-2) + (n-3) + .... + 1
Agora vamos traduzir essa fórmula em termos de programação.
A função recebe um número, e a primeira coisa que ela deve fazer é ver se
esse valor é 1.
Se for, deve retornar 1, afinal:
soma(1) = 1
E se não for 1, deve retornar:
n + soma(n-1)
Isso é feito da uma maneira muito simples, através de um simples teste
condicional do tipo IF ELSE.
Veja como ficou nosso código em C:
#include <stdio.h>
int soma(int n)
{
if(n == 1)
return 1;
else
return ( n + soma(n-1) );
}
int main()
{
int n;
printf("Digite um inteiro positivo: ");
scanf("%d", &n);
printf("Soma: %d\n", soma(n));
}
----------------------------------------------------------------------------------------Exercícios em linguagem C:
1) O programa abaixo implementa duas funções para multiplicar dois
números, sendo uma iterativa e outra recursiva. Analise as duas
chamadas no programa principal e informe passo a passo o resultado
obtido em cada uma.
#include <stdio.h>
long int mult(int x, int y){
long int res=0;
while( y != 0){
res += x; y--;
}
return(res);
}
long int multRec(int x, int y) {
if (y == 0)
return 0;
else
return(x + multRec(x, y-1));
}
int main(){
printf("\nResultado Iterativo: %d",mult(5,600));
printf("\nResultado Recursivo: %d\n\n",multRec(5,600));
return 0;
}
Exercícios 
http://homepages.dcc.ufmg.br/~olmo/exercicios_recursividade.pdf