Recursividade

Introduo
Na linguagem C, assim como em muitas outras linguagens de programao, uma funo pode chamar a si prpria. Uma funo assim chamada funo recursiva. Todo cuidado pouco ao se fazer funes recursivas. A primeira coisa a se providenciar um critrio de parada. Este vai determinar quando a funo dever parar de chamar a si mesma. Isto impede que a funo se chame infinitas vezes.

Introduo
A recursividade uma estratgia que pode ser utilizada sempre que o clculo de uma funo para o valor n, pode ser descrita a partir do clculo desta mesma funo para o termo anterior (n-1).

Introduo
Definio: dentro do corpo de uma funo, chamar novamente a prpria funo.
Recurso direta: a funo A chama a prpria funo A. Recurso indireta: a funo A chama uma funo B que, por sua vez, chama A.

Introduo
Para cada chamada de uma funo, recursiva ou no, os parmetros e as variveis locais so empilhados na pilha de execuo.

Execuo
Internamente, quando qualquer chamada de funo feita dentro de um programa, criado um Registro de Ativao na Pilha de Execuo do programa. O registro de ativao armazena os parmetros e variveis locais da funo bem como o ponto de retorno no programa ou subprograma que chamou essa funo. Ao final da execuo dessa funo, o registro desempilhado e a execuo volta ao subprograma que chamou a funo.

Fatorial
Uma funo que calcule o fatorial de um nmero inteiro n um bom exemplo de uma funo recursiva.
n! = n * (n-1) * (n-2) * (n-3) *....* 1 (n-1)! = (n-1) * (n-2) * (n-3) *....* 1 logo: n! = n * (n-1)!

Fatorial
factorial(6) 6 * factorial(5) 6 * 5 * factorial(4) 6 * 5 * 4 * factorial(3) 6 * 5 * 4 * 3 * factorial(2) 6 * 5 * 4 * 3 * 2 * factorial(1) 6 * 5 * 4 * 3 * 2 * 1 * factorial(0) 6*5*4*3*2*1*1 6*5*4*3*2*1 6*5*4*3*2 6*5*4*6 6 * 5 * 24 6 * 120 720

Fatorial

Exemplo - Fatorial
#include <stdio.h> #include <stdlib.h> int fat(int n) { if (n > 0) 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 eh %d\n", n, fat(n)); system("PAUSE"); return 0; }

Exemplo - Fatorial
Note que, enquanto n no for igual a 0, a funo fat chama a si mesma, cada vez com um valor menor. n=0 critrio de parada para esta funo. H certos algoritmos que so mais eficientes quando feitos de maneira recursiva, mas a recursividade algo a ser evitado sempre que possvel, pois, se usada incorretamente, tende a consumir muita memria e ser lenta. Lembre-se que memria consumida cada vez que o computador faz uma chamada a uma funo. Com funes recursivas a memria do computador pode se esgotar rapidamente.

Complexidade
A complexidade de tempo do fatorial recursivo O(n). Mas a complexidade de espao tambm O(n), devido a pilha de execuo. Ja no fatorial no recursivo a complexidade de espao O(1)
int Fat (int { int f; f = 1; while(n > f = f * n = n } return f; } n)

0){ n; 1;

Complexidade
Portanto, a recursividade nem sempre a melhor soluo, mesmo quando a definio matemtica do problema feita em termos recursivos.

Complexidade
Recursividade vale a pena para Algoritmos complexos, cuja a implementao iterativa complexa e normalmente requer o uso explcito de uma pilha
Dividir para Conquistar (Ex. Quicksort) Caminhamento em rvores (pesquisa, backtracking).

Dividir para Conquistar

Duas chamadas recursivas
Cada uma resolvendo a metade do problema

Muito usado na prtica

Soluo eficiente de problemas Decomposio

No se reduz trivialmente como fatorial

Duas chamadas recursivas

No produz recomputao excessiva como fibonacci

Pores diferentes do problema

Exerccios
Implemente uma funo recursiva para imprimir na tela os nmeros de 1 a 100. Crie uma funo recursiva que calcula a potncia de um nmero (xy). Implemente uma funo recursiva para computar o valor de 2n. Implemente uma funo recursiva para computar a soma dos n primeiros nmeros.

Exerccios (Cont.)
Implemente uma funo recursiva para calcular e imprimir os primeiros n nmeros da Srie de Fibonacci. Fibonacci
fib(1) = 1 fib(2) = 1 fib(n) = fib(n-1) + fib(n-2), para n > 2