UNIVERSIDADE DO EXTREMO SUL CATARINENSE – UNESC

CURSO DE CIÊNCIAS DA COMPUTAÇÃO

LUCAS SPERANDIO BELLOLI MASTELLA

MATHEUS ZANETTE BENEDET

RECURSIVIDADE

CRICIÚMA, MAIO DE 2011.

LUCAS SPERANDIO BELLOLI MASTELLA
MATHEUS ZANETTE BENEDET

RECURSIVIDADE

Trabalho solicitado pela disciplina de Análise

de Algoritmos do curso de Ciência da
Computação da Universidade do Extremo Sul
Catarinense – UNESC.

Orientador: Prof. Paulo João Martins.

CRICIÚMA, MAIO DE 2011.

 SUMÁRIO

1. INTRODUÇÃO..........................................................................................................3

2. OBJETIVO DO TEMA...............................................................................................3

3. EXPLICAÇÃO SOBRE O TEMA..............................................................................3

4. CÓDIGO DE EXEMPLO...........................................................................................4

5. CLASSE DE COMPLEXIDADE................................................................................5

6. EXEMPLOS DE APLICAÇÕES................................................................................5

7. CONCLUSÃO...........................................................................................................6
 3

1. INTRODUÇÃO

Serão tratados problemas matemáticos através de funções recursivas,

mostrando o que é a recursividade.

2. OBJETIVO DO TEMA

Tratar problemas matemáticos através da recursividade.

3. EXPLICAÇÃO SOBRE O TEMA

Em Ciência da Computação, uma função recursiva é uma função que

chama a si mesma. Sendo assim, para evitar que essa função entre em loop é
necessário definir uma condição de término, chamado de “Caso Base”.
Vantagens da recursividade: código mais “enxuto” (conciso) e é excelente
em definições matemáticas, tornando a solução mais simples.
Desvantagens: redução do desempenho de execução devido ao tempo
para gerenciamento de chamadas.
A recursividade funciona da seguinte maneira: cada vez que uma função
é chamada de forma recursiva, é alojado e guardado uma cópia dos seus
parâmetros para não perder os valores dos parâmetros das chamadas anteriores.
Em cada chamada da função, só são diretamente acessíveis os parâmetros criados
para esta chamada, não sendo diretamente acessíveis os parâmetros de outras
instâncias. A informação guardada na chamada de uma função é designada por
Estrutura de Invocação e consiste basicamente na seguinte informação:
• Endereço de retorno (quando a função terminar o programa deve
continuar a sua Execução na linha seguinte à invocação da
função);
 4

• Variáveis passadas como argumentos para a função (por valor,

referência, etc.);
• Estado dos registros e flags do CPU;
• Variável de retorno (por valor, referência,etc.);

O fatorial de um número inteiro positivo é o exemplo clássico utilizado

para se entender a recursividade. O fatorial de n é representado por n! = n * (n-1) *
(n-2) *[...]* 3 * 2 * 1.
Uma função recursiva pode ser representada por uma função não-
recursiva, na qual é necessário guardar uma informação, sendo esta informação
retornada depois do fim da execução da função e o valor retornado é sempre
recuperado e atualizado.
A recursividade deve ser utilizada quando a forma recursiva é a forma
mais simples ou intuitiva de implementar uma solução para resolução do problema.

4. CÓDIGO DE EXEMPLO

/* Número Fatorial Recursivo */

#include <stdio.h>
#include <stdlib.h>
int fat(int n){
if (n) return n*fat(n-1);
else return 1;
}
int main(){
int n;
printf("Fatorial de: ");
scanf("%d", &n);
printf("\nO fatorial de %d eh: %d", n, fat(n));
system("pause>nul");
return 0;
}

/* Sequência de Fibonacci Recursiva */

#include <stdio.h>
#include <conio.h>
int fibonacci(int num)
{
 5

if(num==1 || num==2) return 1;

else return fibonacci(num-1) + fibonacci(num-2);
}
main()
{
int n,i;
printf("Quantidade: ");
scanf("%d", &n);
printf("\nSequencia Fibonacci: ");
for(i=0; i<n; i++) printf("%d ", fibonacci(i+1));
getch();
}

5. CLASSE DE COMPLEXIDADE

Para o exemplo anterior do Número Fatorial e da Sequência de Fibonacci

a complexidade do algoritmo é linear, sendo executado em tempo O(n). É linear
porque é executado uma vez a cada período de tempo que diminui o valor de n até
atingir 0, significando que a função é chamada recursivamente “n” vezes. Isso supõe
que ambos decrementam e são operações constantes.

6. EXEMPLOS DE APLICAÇÕES

Aplicações usualmente geradas com recursividade:

• Número Fatorial;
• Números Harmônicos;
• Número de Fibonacci;
• Percorrer uma árvore;
• Quicksort.
 6

7. CONCLUSÃO

A recursividade então é um método que resolve um problema através de

instâncias menores do mesmo problema. E seu uso gera um código conciso, porém
pode gerar baixo desempenho.