Your SlideShare is downloading. ×
0
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Recursividade
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Recursividade

8,401

Published on

1 Comment
4 Likes
Statistics
Notes
No Downloads
Views
Total Views
8,401
On Slideshare
0
From Embeds
0
Number of Embeds
6
Actions
Shares
0
Downloads
332
Comments
1
Likes
4
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Recursividade Prof. Sérgio Souza Costa
  • 2. Recursividade • Muitas estruturas de dados como listas e árvores são recursivas, então é importante compreender conceito de recursividade. *
  • 3. Recursividade ▪ A recursividade é uma forma de resolver problemas por meio da divisão dos problemas em problemas menores de mesma natureza. ▪ Se a natureza dos subproblemas é a mesma do problema, o mesmo método usado para reduzir o problema pode ser usado para reduzir os subproblemas e assim por diante. ▪ Quando devemos parar? Quando alcançarmos um caso trivial que conhecemos a solução. *
  • 4. Recursividade • Exemplos de casos triviais: – – – – – Qual o fatorial de 0 ? Quanto é um dado X multiplicado por 1 ? Quanto é um dado X multiplicado por 0 ? Quanto é um dado X elevado a 1 ? Quantos elementos tem em uma lista vazia?
  • 5. Recursividade Assim, um processo recursivo para a solução de um problema consiste em duas partes: ▪ ▪ ▪ ▪ ▪ O caso trivial, cuja solução é conhecida; Um método geral que reduz o problema a um ou mais problemas menores (subproblemas) de mesma natureza. Muitas funções podem ser definidas recursivamente. Para isso, é preciso identificar as duas partes acima. Exemplo: fatorial de um número e o n-ésimo termo da seqüência de Fibonacci. *
  • 6. Função fatorial ▪ A função fatorial de um inteiro não negativo pode ser definida como: ▪ Esta definição estabelece um processo recursivo para calcular o fatorial de um inteiro n. Caso trivial: n=0. Método geral: n x (n-1)!. ▪ ▪ *
  • 7. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = *
  • 8. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! *
  • 9. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!)
  • 10. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!) = 4 * (3 * (2 * 1!))
  • 11. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!) = 4 * (3 * (2 * 1!)) = 4 * (3 * (2 * (1 * 0!)))
  • 12. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!) = 4 * (3 * (2 * 1!)) = 4 * (3 * (2 * (1 * 0!))) = 4 * (3 * (2 * (1 * 1)))
  • 13. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!) = 4 * (3 * (2 * 1!)) = 4 * (3 * (2 * (1 * 0!))) = 4 * (3 * (2 * (1 * 1))) = 4 * (3 * (2 * 1))
  • 14. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!) = 4 * (3 * (2 * 1!)) = 4 * (3 * (2 * (1 * 0!))) = 4 * (3 * (2 * (1 * 1))) = 4 * (3 * (2 * 1)) = 4 * (3 * 2)
  • 15. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!) = 4 * (3 * (2 * 1!)) = 4 * (3 * (2 * (1 * 0!))) = 4 * (3 * (2 * (1 * 1))) = 4 * (3 * (2 * 1)) = 4 * (3 * 2) =4*6
  • 16. Função fatorial ▪ Assim, usando-se este processo recursivo, o cálculo de 4!, por exemplo, é feito como a seguir: 4! = 4 * 3! = 4 * (3 * 2!) = 4 * (3 * (2 * 1!)) = 4 * (3 * (2 * (1 * 0!))) = 4 * (3 * (2 * (1 * 1))) = 4 * (3 * (2 * 1)) = 4 * (3 * 2) =4*6 = 24 Mas como uma função recursiva é de fato implementada no computador? Usando-se o mecanismo conhecido como Pilha de Execução! *
  • 17. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Pilha de Execução fatorial(4) -> return 4*fatorial(3) *
  • 18. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Pilha de Execução fatorial(3) -> return 3*fatorial(2) fatorial(4) -> return 4*fatorial(3) *
  • 19. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Pilha de Execução fatorial(2) -> return 2*fatorial(1) fatorial(3) -> return 3*fatorial(2) fatorial(4) -> return 4*fatorial(3) *
  • 20. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Pilha de Execução fatorial(1) -> return 1*fatorial(0) fatorial(2) -> return 2*fatorial(1) fatorial(3) -> return 3*fatorial(2) fatorial(4) -> return 4*fatorial(3) *
  • 21. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Pilha de Execução fatorial(0) fatorial(1) -> return 1 (caso trivial) -> return 1*fatorial(0) fatorial(2) -> return 2*fatorial(1) fatorial(3) -> return 3*fatorial(2) fatorial(4) -> return 4*fatorial(3) *
  • 22. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Pilha de Execução Desempilha fatorial(0) fatorial(0) fatorial(1) -> return 1 (caso trivial) -> return 1*fatorial(0) fatorial(2) -> return 2*fatorial(1) fatorial(3) -> return 3*fatorial(2) fatorial(4) -> return 4*fatorial(3) *
  • 23. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Desempilha fatorial(1) fatorial(1) -> return 1*1 fatorial(2) -> return 2*fatorial(1) fatorial(3) fatorial(4) -> return 3*fatorial(2) -> return 4*fatorial(3) *
  • 24. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Desempilha fatorial(2) fatorial(2) -> return 2*1*1 fatorial(3) -> return 3*fatorial(2) fatorial(4) -> return 4*fatorial(3) *
  • 25. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Desempilha fatorial(3) fatorial(3) -> return 3*2*1*1 fatorial(4) -> return 4*fatorial(3) *
  • 26. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Desempilha fatorial(4) fatorial(4) -> return 4*3*2*1*1 *
  • 27. Função fatorial ▪ Considere, novamente, o exemplo para 4!: Resultado = 24 *
  • 28. Recursividade "Para fazer um procedimento recursivo é preciso ter fé.” prof. Siang Wun Song *
  • 29. Recursividade "Para fazer um procedimento recursivo é preciso ter fé.” prof. Siang Wun Song "Ao tentar resolver o problema, encontrei obstáculos dentro de obstáculos. Por isso, adotei uma solução recursiva.” Aluno S.Y., 1998 *
  • 30. Recursividade "Para fazer um procedimento recursivo é preciso ter fé.” prof. Siang Wun Song "Ao tentar resolver o problema, encontrei obstáculos dentro de obstáculos. Por isso, adotei uma solução recursiva.” Aluno S.Y., 1998 "To understand recursion, we must first understand recursion.” —anônimo *
  • 31. Funções recursivas • Base do paradigma funcional. – ○ Lisp, Haskell, Miranda, F#, Scheme, Erland – Influenciou diversas: JavaScript, Python,Ruby, Lua • Presente em praticamente todas as linguagens, mesmo as imperativas, como – C, Java, Pascal, ADA ... *
  • 32. Funções recursivas • Muitos algoritmos complexos são resolvidos através de soluções recursivas – Quick-sort (ordenação rápida) – Ordenação por intercalação (merge sort) – Busca binária • Muitas estruturas de dados são recursivas – Listas encadeadas – Árvores binárias, n-árias ... • Tendem a gerar códigos menores *
  • 33. Recursividade - Natureza *
  • 34. Recursividade - Natureza *
  • 35. Vamos fazer mais um exercício. Na atividade de aprofundamento tem mais exercícios. Tentem fazer e postem suas dúvidas.
  • 36. Exercício resolvido • Codifiquem uma função que multiplica um dado inteiro “a” por um inteiro “b”, usando somas sucessivas. Exemplo: • 4 * 3 = 3+ 3+ 3 +3 = 12
  • 37. Exercício resolvido int mult (int a, int b) { }
  • 38. Exercício resolvido int mult (int a, int b) { if (a == 0) return }
  • 39. Exercício resolvido int mult (int a, int b) { if (a == 0) return 0; }
  • 40. Exercício resolvido int mult (int a, int b) { if (a == 0) return 0; if (a == 1) return }
  • 41. Exercício resolvido int mult (int a, int b) { if (a == 0) return 0; if (a == 1) return b; }
  • 42. Exercício resolvido int mult (int a, int b) { if (a == 0) return 0; if (a == 1) return b; return b + mult (a-1,b); }
  • 43. Vamos testar ?
  • 44. Vamos testar ? mult (3,5)
  • 45. Vamos testar ? mult(3,5)=5+mult(2,5)
  • 46. Vamos testar ? mult(3,5)=5+mult(2,5) =5+5+mult(1,5)
  • 47. Vamos testar ? mult(3,5)=5+mult(2,5) =5+5+mult(1,5) =5+5+5
  • 48. Vamos testar ? mult(3,5)=5+mult(2,5) =5+5+mult(1,5) =5+5+5 = 15
  • 49. Exercícios 1. Faça uma função recursiva que calcula a divisão usando subtrações sucessivas int div (int a, int b); 2. Faça uma função recursiva que calcula o resto de uma divisão usando subtrações sucessivas. int mod (int a, int b); 3.Faça uma função recursiva que calcula a potencia de um numero usando multiplicações sucessivas. int pot (int base, int exp); 4. Faça uma função recursiva que calcula a quantidade de caracteres em uma string. int tamanho (char *str) 5. Fazer uma função recursiva que calcule o valor da série S descrita a seguir para um valor n > 0 a ser fornecido como parâmetro para a mesma: S = 1 + 1/2! + 1/3! + ... 1/n!
  • 50. Tipos Recursivos Um tipo recursivo é definido em termos de si. Exemplos de tipos recursivos: ● listas ● árvores A cardinalidade de tipos recursivos é infinita. Os números naturais é outro exemplo de tipos recursivos
  • 51. Axiomas de Peano O matemático Giuseppe Peano (1858-1932) apresentou alguns axiomas sobre números naturais, que ficaram posteriormente conhecidos como os Axiomas de Peano. Nele precisamos admitir três conceitos primitivos. São eles: zero (denotado por 0), número natural e a noção de sucessor de um número natural. Estes axiomas são listados abaixo: (A1) 0 (zero) é um número natural e não é sucessor de um número natural2. (A2) Todo número natural tem um único sucessor, que também é um número natural. (A3) Se dois números naturais tem o mesmo sucessor, então eles são iguais entre si. (A4) Se um subconjunto S dos números naturais possui o elemento zero e também o sucessor de todos os elementos de S, então S é igual ao conjunto dos números naturais.
  • 52. Tipos Recursivos - Naturais Exemplos: 0 -> Zero
  • 53. Tipos Recursivos - Naturais Exemplos: 0 -> Zero 1 -> Succ (Zero)
  • 54. Tipos Recursivos - Naturais Exemplos: 0 -> Zero 1 -> Succ (Zero) 2- > Succ ( Succ (Zero))
  • 55. Tipos Recursivos - Naturais Exemplos: 0 -> Zero 1 -> Succ (Zero) 2- > Succ ( Succ (Zero)) 3- > Succ ( Succ ( Succ (Zero))) ...
  • 56. Numeros Naturais typedef struct Nat { struct Nat* ant; }* Nat; Definição da estrutura. Observe a recursão. Função que define o Zero Nat Zero () { return NULL; } Nat Succ (Nat a) { Nat n = malloc (sizeof (Nat)); Função que retorna o n->ant = a; sucessor de um dado a. return n; } Função que retorna o Nat ant (Nat a) { antecessor de um dado return a->ant; a. }
  • 57. Numeros Naturais typedef struct Nat { struct Nat* ant; }* Nat; Definição da estrutura. Observe a recursão. Função que define o Zero Nat Zero () { return NULL; } Nat Succ (Nat a) { Nat n = malloc (sizeof (Nat)); Função que retorna o n->ant = a; sucessor de um dado a. return n; Em C, ponteiros é o } recurso que nos Função que retorna o Nat ant (Nat a) { permite definir tipos antecessor de um dado return a->ant; recursivos a. }
  • 58. Numeros Naturais Se b é o número 1, então a + b é definido como sucessor de a. Por outro lado, se b fosse 2, a + b seria definido como sucessor de a + 1. Ou seja, a + c é o sucessor de a + b, onde b é o antecessor de c. Isso pode ser descrito na seguinte função: Nat sum (Nat if (c == return else { return } } a, Nat c) { Zero () ) a; Succ ( sum (a, ant(c)));
  • 59. Numeros Naturais A multiplicação pode ser definida em termos de soma sucessivas. Nat mult (Nat a, Nat b) { if (a == Zero () ) return Zero (); else return sum (b, (mult (b, ant(a)))); }
  • 60. Numeros Naturais A multiplicação pode ser definida em termos de soma sucessivas. Nat mult (Nat a, Nat b) { if (a == Zero () ) return Zero (); else return sum testem o Baixem e (b, (mult (b, ant(a)))); } código.
  • 61. Atividade 1. Codifiquem a divisão inteira. 2. Codifiquem a função que retorna o resto de uma divisão inteira, ou seja, equivalente ao operador %.

×