Programação II RECURSÃO

Transcrição

1 Programação II RECURSÃO Bruno Feijó Dept. de Inormática, PUCRio

2 Motivação Escher: Metamorphosis (197) Drawing Hands (1948) Relativity (195) Alguém diz: Esta sentença é alsa! Paradoxo do Cretense Mentiroso um homem natural de Creta, em praça pública, anuncia: Todo cretense é mentiroso! Estas sentenças são Verdadeiras ou Falsas? O que há de comum neste slide? RECURSÃO! 2

3 Deinições Recursivas Em uma deinição recursiva um item é deinido em termos de si mesmo, ou seja, o item que está sendo deinido aparece como parte da deinição;

4 Conceito de Recursão Em uma deinição recursiva um item é deinido em termos de si mesmo, ou seja,o item que está sendo deinido aparece como parte da deinição; Mas, atenção: a deinição (x) (x) não revela nada sobre a unção. A deinição recursiva da unção atorial at(n) = n (n 1) 1 é a seguinte: 1, se n 0 at( n) n at( n 1), se n 0 Caso Base Recorrência (ou Passo Indutivo) Chamada Recursiva (ou Hipótese Indutiva) Uma deinição recursiva é deinida por um ou mais casos base e por um ou mais passos indutivos envolvendo a chamada da própria unção (denominada chamada recursiva ). O caso base é uma situação trivial da unção, onde calcular o valor da unção é imediato, direto e trivial. O passo indutivo é a aplicação recursiva da unção em uma versão de menor porte do problema. Imagine o passo indutivo como sendo um degrau, situado logo abaixo do nível do problema proposto originalmente, em direção a um caso base. A maior diiculdade neste método de resolver problemas é termos coniança na solidez desse degrau! Isto é: coniança na validade de adotarmos a Hipótese Indutiva. que corresponde a supor a versão de menor porte do problema como estando completamente resolvida. Isto é um método indutivo para resolver problemas. O termo indutivo é usado para salientar que a solução em um passo é induzida pela solução do passo anterior. A relação entre recursão e indução é apresentada mais a rente. 4

5 O processo da Recursão A deinição recursiva é uma maneira de especiicar a solução de uma instância de um problema de tamanho n em termos de soluções para instâncias menores. at() = at(2) Problema tamanho n at(2) = at(1) at(1) = 2 at(0) at(0) = 1 Caso base Neste processo, criase uma pilha de operações pendentes (uma expansão) que são resolvidas quando se encontra o caso base (uma contração). Por exemplo: expansão contração at() * at(2) * (2 * at(1)) * (2 * (1 * at(0))) * (2 * (1 * 1)) Caso Base * (2 * 1) * 2 6 5

6 Implementação de uma Deinição Recursiva Seja a deinição recursiva de atorial: at(0) = 1 at(n) = n at(n 1) Uma vez que encontramos a deinição recursiva de uma unção, a implementação é direta, simples, um trabalho automático: int at (int n) i (n==0) return 1; return n*at(n1); Você pode veriicar se a sua deinição e a sua implementação estão corretas acompanhando a execução de um exemplo: Este acompanhamento chamase TRAÇO. Não dependa de azer o traço para encontrar a deinição recursiva de uma unção. Use o traço para veriicar e não para criar a solução. Ademais, somente unções matemáticas admitem o TRAÇO. Traço não az sentido para procedimentos (e.g. unções em C que disparam ações e/ou não retornam valor). Nestes casos, acompanhamse as variáveis do procedimento. As variáveis deinem o estado do mundo. e nem sempre é ácil acompanhar o estado do mundo! 6

7 Outro Exemplo de Deinição Recursiva A deinição recursiva da soma da série de números naturais, g(n) =1 2 n, é: g(1) = 1 g(n) = g(n 1) + n Este exemplo é mais interessante que o do atorial, porque há uma bela orma echada que representa esta soma: 1 2 n = n(n 1)/2 Nem toda a deinição recursiva tem uma bela orma echada ( raras têm!). Aliás, quando tem, não az sentido implementar a unção recursivamente no computador. A implementação recursiva de g(n) também é imediata: int g(int n) i (n == 1) return 1; return n + g(n 1); Note que não existem construtores de loop (e.g. or ou while) na implementação de deinições recursivas! Há amílias de linguagens que não têm estes construtores (or e while), porque usam recursão (e.g. linguagens uncionais, como Lisp, e linguagens de programação em lógica, como Prolog). 7

8 Recursão e Indução (Material Avançado) Existe uma estreita ligação entre indução e deinições recursivas. Indução é talvez a orma mais natural de raciocinar sobre processos recursivos. Indução é um método para provar que uma airmação S(n) é válida para todo n: Primeiro mostre que S(1) (ou S(0)) é valida Depois assuma que S(k) é válida (esta é a hipótese indutiva) Mostre que S(k+1) é válida Então, S(n) é válida para todo n. Um exemplo clássico: provar que 1 2 n = n(n 1)/2 para todo n S(1) = 1(1 1)/2 = 1, i.e. S(1) é válida! Hipótese: 1 2 k = k(k 1)/2 é uma airmação válida Demonstração que S(k+1) é válida, i.e. 1 2 k (k 1)= (k 1)(k 2)/2 Pela hipótese, o lado esquerdo é k(k 1)/2 (k 1) Colocando (k 1) em evidência, temse: (k 1)(k/2 +1), i.e. (k 1)(k 2)/2 Indução cai naturalmente no mesmo paradigma da deinição recursiva. São duas variantes do mesmo tema. A orma recursiva para o exemplo acima já vimos que é: Este assunto não cai em provas. São inormações que ajudam a entender recursão. g(1) = 1 g(n) = g(n 1) + n Nem toda a deinição recursiva tem uma bela orma echada (como a n(n 1)/2) 8

9 Um Roteiro para Encontrar Soluções Recursivas Devemos observar que, no método indutivo, o problema vai sucessivamente caindo em problemas de menor porte, até que o caso base é alcançado. O passo indutivo corresponde a descobrirmos como modiicar o valor vindo da chamada recursiva para ter o resultado inal procurado. E o que devemos azer é sempre muito simples, como uma espécie de retoque inal (pois o maior trabalho já oi eito pela hipótese indutiva, ou seja: pela chamada recursiva) Não começe tentando simular a execução (deixe isto como teste após encontrar solução. Como um roteiro aça sempre o seguinte (até icar automático no seu cérebro): 1. Deina o domínio e a imagem da unção (lembre que são conjuntos: conjunto dos naturais, conjunto de todos os strings,...). E entenda o que a unção az (escreva exemplos). Saber o que a unção az, ajuda muito a encontrar a chamada recursiva!!! 2. Veriique se há precondições (e.g. algum valor não permitido, ou se é simplesmente a condição de pertencer ao domínio, ou...).. Identiique os elementos mais neutros, simples, do domínio. Os casos base geralmente (mas não necessariamente) dizem respeito a eles. 4. Formule os casos base 5. Encontre as chamadas recursivas (um degrau a menos na direção do caso base). A chamada recursiva resolve a maior parte do problema e retorna um valor concreto. 6. Encontre os passos indutivos como sendo um retoque que você az com o valor recebido da chamada recursiva. Se você começar a complicar, é sinal de que está errado!! Com a prática, junte 5 e 6. Depois de ormular a solução conceitual, pense em como uncionará na máquina, esboçando o código! 9

10 Solução Conceitual Usando o roteiro do slide anterior, primeiro escreva um esboço de solução da maneira mais independente possível da linguagem de computador em questão. Vamos chamar esta solução de Solução Conceitual. Por exemplo: Problema de Ordemn: at(n) : Precondição: não há situações especiais n Caso(s) Base: n=0 at(n) = 1 Hipótese Indutiva (Chamada Recursiva): at(n1) Passo(s) Indutivo(s): at(n) = n * at(n1) R S naturais (inteiros nãonegativos) inteiros (neg. e nãonegativos). reais conjunto das strings Depois escreva o Código! E, por im, tente seguir a execução do Código.

11 EXEMPLOS 11

12 Tamanho e Cópia de Strings int main(void)... print("\ntamanho= %d\n",stringlen(a)); stringcopy(n,"ana"); print("n=%s\n",n); stringcopy(n,"oi"); print("n=%s\n",n); print("n[2]=%d n[]=%d\n\n",n[2],n[]); tamanho= n=ana n=oi n[2]=0 n[]=0 valor numérico de \0 é 0 (zero). Imprimir \0 como %c dá branco Escreva as unções stringlen e stringcopy recursivamente. Não veja as respostas nos slides seguintes. Tente resolver!

13 Exemplo: tamanho de um string Solução conceitual: tamanho(s): S N se s é vazia então tamanho é 0 caso contrário tamanho(s) = 1 + tamanho do resto da string int tamanho(char * s) i (*s == '\0') return 1 + tamanho(s+1); int tamanho(char * s) // versao com sintaxe [] de indices i (s[0] == '\0') return 1 + tamanho(&s[1]); 1

14 #include <stdio.h> void imprimestr(char *); int main(void) char s[] = "Bom Dia"; imprimestr(s); print("\n"); Exemplo imprimir string void imprimestr(char * s) // versao ponteiro i (*s) // ou: i (*s!= '\0') print("%c",*s); Imprimir string invertido: imprimestr(s+1); /* versao vetor void imprimestr(char * s) */ i (s[0]) // ou: i (s[0]!= '\0') print("%c",s[0]); imprimestr(&s[1]); Solução conceitual imprime(s) se s é vazia então nada imprime caso contrário imprime 1 caractere de s e depois imprime resto da string void imprimeinv(char * s) i (*s) imprimeinv(s+1); print("%c",*s); 14

15 #include <stdio.h> void stringcopy(char *, char *); Exemplo stringcopy int main(void) char s[] = "Bom Dia"; char * a = (char *)malloc(51); stringcopy(a,s); ou de maneira mais concisa void stringcopy(char * s, char * t) i (*s = *t) stringcopy(s+1,t+1); Solução conceitual stringcopy(s,t) copia t para s se t é vazia, então s é vazia caso contrário copia 1 caractere de t para s e copia restante da string t para a próxima posição de s void stringcopy(char * s, char * t) i (*t == '\0') *s == '\0 ; *s = *t; stringcopy(s+1,t+1); Ou ainda: void stringcopy(char * s, char * t) *s = *t; i (*t) stringcopy(s+1,t+1); Ou usando sintaxe [ ] de índice: void stringcopy(char * s, char * t) s[0] = t[0]; i (t[0]) // ou i (t[0]!= '\0 ) stringcopy(&s[1],&t[1]); 15

16 Exemplo: Potenciação Exemplo: unção recursiva para cálculo de potenciação /* Função recursiva para cálculo de potenciacao */ int pot (int x, int n) i (n==0) return 1; return x*pot(x,n1); Caso BASE Passo Recursivo 16

17 Exemplo com 2 Casos Base e 2 Chamadas Recursivas Série de Fibonacci (um termo é a soma dos dois anteriores): 0, 1, 1, 2,, 5, 8, Deinição recursiva da Série de Fibonacci: Implementação: ib(0) = 0 ib(1) = 1 ib(n) = ib(n 1) + ib(n 2) se n 1 int ib (int n) i (n==0) i (n==1) return 1; return (ib(n1) + ib(n2)); 17

18 ILUSTRAÇÃO DA RECURSÃO EM C 18

19 Funções Recursivas Tipos de recursão: direta: uma unção A chama a ela própria indireta: uma unção A chama uma unção B que, por sua vez, chama A Comportamento: quando uma unção é chamada recursivamente, criase um ambiente local para cada chamada as variáveis locais de chamadas recursivas são independentes entre si, como se estivéssemos chamando unções dierentes 19

20 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at() n r main n

21 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at(2) n at() n r main n 2

22 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at(1) n at(2) n at() n r main n 1 2

23 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at(0) n at(1) n at(2) n at() n r main n 0 1 2

24 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at(0) n at(1) n at(2) n at() n r main n

25 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at(1) n at(2) n at() n r main n 1 1 2

26 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at(2) n at() n r main n 2 2

27 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo at() n r main n 6

28 Funções Recursivas #include <stdio.h> int at (int n); int main (void) int n = ; int r; r = at ( n ); print("fatorial de %d = %d \n", n, r); /* Função recursiva para cálculo do atorial */ int at (int n) int ; i (n==0) =1; = n*at(n1); return ; 08/0/10 (c) Casanova, Gattass, Viterbo main r n 6

29 Reerências Waldemar Celes, Renato Cerqueira, José Lucas Rangel, Introdução a Estruturas de Dados, Editora Campus (2004) Capítulo 4 Funções (pag. 54) Capítulo 7 Cadeias de caracteres (pag. 91) 29