• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Logica Algoritmo 08 Recursividade
 

Logica Algoritmo 08 Recursividade

on

  • 17,366 views

 

Statistics

Views

Total Views
17,366
Views on SlideShare
17,174
Embed Views
192

Actions

Likes
4
Downloads
362
Comments
1

2 Embeds 192

http://www.slideshare.net 104
http://www.prof.kadu.com.br 88

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

11 of 1 previous next

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

    Logica Algoritmo 08 Recursividade Logica Algoritmo 08 Recursividade Presentation Transcript

    • Lógica de Programação Recursividade
        • Regis Pires Magalhães
        • [email_address]
        • Última atualização em 07/08/2008
    • Recursividade
      • Um algoritmo que para resolver um problema divide-o em subprogramas mais simples, cujas soluções requerem a aplicação dele mesmo, é chamado recursivo, seja de forma direta ou indireta.
      • Em geral, uma rotina recursiva R pode ser expressa como uma composição formada por um conjunto de comandos C (que não contém chamadas a R) e uma chamada (recursiva) à rotina R:
      Recursão Direta
    • Exemplo
      • Fatorial
        • A definição de fatorial é:
          • F(n) = 1 se n = 0 ou n = 1;
          • F(n) = n * F(n-1), se n>1.
          • onde n é um numero inteiro positivo. Uma propriedade (facilmente verificável) dos fatoriais é que:
            • n! = n * (n-1)!
        • Esta propriedade é chamada de propriedade recursiva: o fatorial de um numero pode ser calculado através do fatorial de seu antecessor.
          • F(4) = 4 * F(4-1)‏
          • F(3) = 3 * F(3-1)‏
          • F(2) = 2 * F(2-1)‏
          • F(1) = 1 * F(1-1)‏
          • F(0) = 1
    • Caso base ou Condição de Parada
      • Como uma função recursiva pode chamar a si mesma indefinidamente, é essencial a existência do caso base, ou condição de parada.
    • Forma geral
      • Esquematicamente, os algoritmos recursivos têm a seguinte forma:
      • se "condicao para o caso de base" entao
      • resolucao direta para o caso de base
      • senao
      • uma ou mais chamadas recursivas
      • fimse
    • Caso Base
      • Um algoritmo recursivo pode ter um ou mais casos de base e um ou mais casos gerais.
      • E para que o algoritmo termine, as chamadas recursivas devem convergir em direção ao caso de base, senão o algoritmo não terminará jamais.
      • Convergir significa ter uma parte menor do problema para ser resolvido.
      • F(4) = 4.F(4-1)‏
      • F(3) = 3.F(3-1)‏
      • F(2) = 2.F(2-1)‏
      • F(1) = 1.F(1-1)‏
      • F(0) = 1 ------------ Caso Base
      • F(1) = 1.1
      • F(2) = 2.1
      • F(3) = 3.2
      • F(4) = 4.6
    • Exemplo
      • algoritmo "fatorial"
      • var
      • numero: inteiro
      • funcao fat (n:Inteiro):Inteiro
      • inicio
      • se n=0 entao
      • retorne 1
      • senao
      • retorne n * Fat (n-1)‏
      • fimse
      • fimfuncao
      • inicio
      • escreva("Digite um número: ")‏
      • leia (numero)‏
      • escreval("O fatorial de ", numero, " é ", fat(numero))‏
      • fimalgoritmo
    • Exemplo não recursivo
      • algoritmo "fatorial"
      • var
      • numero: inteiro
      • funcao fat (n:Inteiro):Inteiro
      • var i, resultado : inteiro
      • inicio
      • resultado <- 1
      • para i de n ate 1 passo -1 faca
      • resultado <- resultado * i
      • fimpara
      • retorne resultado
      • fimfuncao
      • inicio
      • escreva(&quot;Digite um número: &quot;)‏
      • leia (numero)‏
      • escreval(&quot;O fatorial de &quot;, numero, &quot; é &quot;, fat(numero))‏
      • fimalgoritmo
    • Algoritmos Recursivos x Iterativos
      • Todo algoritmo recursivo possui um algoritmo iterativo equivalente, mudando apenas a sua complexidade de construção.
      • Vantagens
        • Simplifica a solução de alguns problemas
        • Algoritmos recursivos são mais compactos para alguns tipos de algoritmo, mais legíveis e mais fáceis de ser compreendidos e implementados .
      • Desvantagens
        • Por usarem intensivamente a pilha de execução, os algoritmos recursivos tendem a ser mais lentos e a consumir mais memória que os iterativos, porém pode valer a pena sacrificar a eficiência em benefício da clareza.
        • Erros de implementação podem levar a estouro de pilha. Isto é, caso não seja indicada uma condição de parada, ou se esta condição nunca for satisfeita, entre outros.
    • Recursão Indireta
      • Entretanto, pode-se ter também uma forma indireta de recursão, na qual as rotinas são conectadas através de uma cadeia de chamadas recursivas que acaba retornando a primeira que foi chamada:
    • Torres de Hanói
      • Quebra-cabeças com uma base de 3 pinos, onde num deles, são dispostos discos uns sobre os outros, em ordem crescente de diâmetro, de cima para baixo.
      • O problema consiste em passar todos os discos de um pino para outro qualquer, usando um dos pinos como auxiliar, de maneira que um disco maior nunca fique em cima de outro menor em nenhuma situação.
      • O número de discos pode variar, sendo que o mais simples contém apenas três.
    • A Lenda
      • &quot;No grande templo de Benares, embaixo da cúpula que marca o centro do mundo, repousa uma placa de latão onde estão presas três agulhas de diamante, cada uma com 50 cm de altura e com espessura do corpo de uma abelha.
      • Em uma dessas agulhas, durante a criação, Deus colocou sessenta e quatro discos de ouro puro, com o disco maior repousando sobre a placa de latão e os outros diminuindo cada vez mais ate o topo.
      • Essa é a torre de Brahma. Dia e noite, sem parar, os sacerdotes transferem os discos de uma agulha de diamante para outra de acordo com as leis ficas e imutáveis de Brahma, que exigem que o sacerdote em vigília não mova mais de um disco por vez e que ele coloque este disco em uma agulha de modo que não haja nenhum disco menor embaixo dele.
      • Quando os sessenta e quatro discos tiverem sido assim transferidos da agulha em que a criação de Deus as colocou para uma das outras agulhas, a torre, o templo e os brâmanes virarão pó, e com um trovejar, o mundo desaparecerá.&quot;
    • Solução
      • Algoritmo para mover N discos de A para C, usando B como auxiliar:
        • 1. Se N==1, mova o único disco de A para C e pare.
        • 2. Se N>1:
          • 1. Mova os N-1 discos superiores de A para B, usando C como auxiliar (passo 2 da figura abaixo).
          • 2. Mova o disco restante de A para C (passo 3 da figura abaixo).
          • 3. Mova os N-1 discos de B para C, usando A como auxiliar (passo 4 da figura abaixo).
    • Solução
    • Solução Ótima
      • O número mínimo de &quot;movimentos&quot; para conseguir transferir todos os discos é 2 n -1, sendo n o número de discos.
      • Logo:
        • Para 3 discos , são necessários 7 movimentos
        • Para 7 discos, são necessários 127 movimentos
        • Para 15 discos, são necessários 32.767 movimentos
        • Para 64 discos, como diz a lenda, são necessários 18.446.744.073.709.551.615 movimentos.
    • Solução Recursiva
      • A solução para o problema da Torre de Hanoi com recursividade é compacta e baseia-se no seguinte:
        • A única operação possível de ser executada é &quot;move disco de um pino para outro&quot;;
        • Uma torre com (N) discos, em um pino, pode ser reduzido ao disco de baixo e a torre de cima com (N-1) discos;
        • A solução consiste em transferir a torre com (N-1) discos do pino origem para o pino auxiliar, mover o disco de baixo do pino origem para o pino destino e transferir a torre com (N-1) discos do pino auxiliar para o pino destino. Como a transferência da torre de cima não é uma operação possível de ser executada, ela deverá ser reduzida sucessivamente até transformar-se em um movimento de disco.
    • Solução Recursiva
    • Algoritmo
      • algoritmo &quot;hanoi&quot;
      • var num_discos, numero_movimentos : inteiro
      • procedimento transfere(n : inteiro; origem, destino, auxiliar : caracter)‏
      • inicio
      • se (n = 1) entao
      • numero_movimentos <- numero_movimentos + 1
      • escreval(numero_movimentos, &quot; - Mova de &quot; , origem, &quot; para &quot; , destino)‏
      • senao
      • transfere(n-1, origem, auxiliar, destino)‏
      • numero_movimentos <- numero_movimentos + 1
      • escreval(numero_movimentos, &quot; - Mova de &quot; , origem, &quot; para &quot; , destino)‏
      • transfere(n-1, auxiliar, destino, origem)‏
      • fimse
      • fimprocedimento
      • inicio
      • escreva( &quot;Digite o número de discos: &quot; )‏
      • leia(num_discos)‏
      • transfere(num_discos, &quot;A&quot; , &quot;C&quot; , &quot;B&quot; )‏
      • escreval(&quot;Número total de movimentos: &quot;, numero_movimentos)‏
      • fimalgoritmo