Recursividade
Upcoming SlideShare
Loading in...5
×
 

Recursividade

on

  • 3,140 views

 

Statistics

Views

Total Views
3,140
Views on SlideShare
1,972
Embed Views
1,168

Actions

Likes
1
Downloads
57
Comments
0

3 Embeds 1,168

http://edgarddavidson.com 1150
http://horaextrabh.org 17
http://translate.googleusercontent.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Recursividade Recursividade Presentation Transcript

  • Recursividade
    Prof. Edgard Davidson C. Cardoso
  • Introdução
    Um método é considerado recursivo quando possui uma chamada para si próprio
    f(int x){
    ....
    f(x)
    }
    Um método recursivo pode ser chamado direta ou indiretamente por outro método.
    f() -> g() -> f()
  • Introdução
    Condições para a aplicação da recursividade
    O problema possa ser decomposto em subproblemas que representem instâncias menores daquele original
    O processo de decomposição seja finito e limitado, ou seja, a cada nova instância o subproblema resultante é menor que o antecede, e o número de instâncias não seja grande.
  • Introdução
    Em geral, há dois tipos básicos de problemas que admitem soluções recursivas:
    Os que são compostos por problemas que apresentam uma decomposição naturalmente recursiva em subproblemas de mesma classe, como o cálculo do fatorial de um número;
    Os problemas que tratam estruturas de dados naturalmente recursivas, como as listas encadeadas, as árvores ou algoritmos de ordenação como MergeSort, QuickSort
  • Algoritmo Recursivo
    Algoritmo recursivo
    Início
    Se a condição de término for atingida
    então
    Resolver o problema
    senão
    Partir o problema em problemas mais pequenos,
    usando para esse efeito, uma ou mais invocações recursivas
    Fim
  • Algoritmo Recursivo X Não Recursivo
    Implementação não Recursiva
    intFatorial (int N){
    int i, fat= 1;
    if(N < 0) return0; // invocação anormal (valor devolvido 0)
    for (i = 2; i <= N; i++)
    fat= fat* i; // cálculo do produto
    returnfat; // devolução do valor calculado
    }
  • Algoritmo Recursivo X Não Recursivo
    Implementação Recursiva
    intFatorial (int N){
    if(N < 0) return 0; // invocação anormal (valor devolvido 0)
    if(N == 0) return 1; // condição de paragem
    return(N * Fatorial (N-1)); // invocação recursiva
    }
  • Inserção em uma árvore binária
    voidinsereRecursivo(eMatriz *elem, NodoAB *sub) {
    if(elem < sub->valor){
    if(sub->esq == NULL)
    sub->esq = newNodoAB(elem, NULL, NULL);
    else
    insereRecursivo(elem, sub->esq);
    }
    else{
    if(sub->dir == NULL)
    sub->dir = newNodoAB(elem, NULL, NULL);
    else
    insereRecursivo(elem, sub->dir);
    }
    }
    void Arvore::insere(eMatriz *elem){
    if(raiz == NULL)
    raiz = newNodoAB(elem, NULL, NULL);
    else
    insereRecursivo(elem, raiz);
    }
  • Recursão Excessiva
    A sequência produzida pela definição é:
    0,1,1,2,3,5,8,13,21,34,55,89,...
    unsignedintFib (unsignedint n){
    if (n < 2)
    return n;
    else
    returnFib(n-2) + Fib (n-1);
    }
  • Recursão Excessiva
    A função é de fácil entendimento, mas extremamente ineficiente.
    F(6)
    F(4)
    F(5)
    F(2)
    F(3)
    F(3)
    F(4)
    F(1)
    F(2)
    F(1)
    F(2)
    F(0)
    F(1)
    F(2)
    F(3)
    F(0)
    F(1)
    F(0)
    F(1)
    0
    1
    1
    1
    F(1)
    F(2)
    F(0)
    F(1)
    0
    1
    0
    1
    F(0)
    F(1)
    0
    1
    1
    0
    1
  • Recursão Excessiva
    Comparação dos algoritmos iterativo e recursivo para calcular os números de Fibonacci.
  • Conclusão
    Recursão deve ser usada com critério
    Usualmente é menos eficiente que seu equivalente iterativo
    Há vantagem em clareza, legibilidade e simplicidade de código.
    A conversão para uma versão iterativa nem sempre é uma tarefa trivial
    Métodos recursivos podem ser substituídos por estruturas de pilhas
  • Atividade
    Dado:
    Escrever uma função recursiva que eleve qualquer número x a uma potência inteira não negativa n.
    doube potencia (double x, unsignedint n){
    ...
    ...
    ...
    }