Exemplo-1 Exemplo-1 - solução - IC

Recursividade
Recursividade é a capacidade de um programa (função)
fazer uma ou mais chamadas a si mesmo.
Na execução de um programa recursivo, uma pilha é
responsável pelo armazenamento das variáveis recursivas
Uma função recursiva tem que seguir duas regras básicas:
Ter uma condição de parada (para garantir que uma chamada
recursiva não criará um loop infinito)
Tornar o problema mais simples
Genericamente um módulo recursivo segue o algoritmo abaixo:
Exemplo-1
Implementar a multiplicação de inteiros utilizando somas
sucessivas.
Exemplo: Calcular A X B para A=4 e B= 5
4 X 5 = 4 + (4 X 4)
4+(4 X 3)
4 +(4 x 2)
4 + (4 X1)
4 +(4 X 0) quando B=0 retorna 0
SE <condição de parada satisfeita> Retornar
senão Divida o problema num caso mais simples
utilizando recursão
Exemplo-1 - solução
#include <stdio.h>
int Multiplica(int a, int b) {
if (b== 0) return b;
else return a + Multiplica(a,b-1);
}
Pilha da função recursiva
Retorna 0
Retorna 4+0
Retorna 4+4
Retorna 4+8
Retorna 4+12
#include <stdio.h>
int Multiplica(int a, int b) {
if (b== 0) return b;
else return a + Multiplica(a,b-1);
}
int main(){
int a, b, resul;
Multiplica(4,0)
printf("forneca valores para a e b");
Multiplica(4,1)
scanf("%d%d", &a, &b);
resul=Multiplica(a,b);
printf("resultado=%d",resul);
getch();
return 0;
Multiplica(4,2)
Multiplica(4,3)
Multiplica(4,4)
Multiplica(4,5)
}
Retorna 4+16
Exemplo - 2
Apresente um esquema recursivo para dividir dois número inteiros usando
contagens sucessivas.
Por exemplo: calcular A/B sendo A=18 e B=4.
Parte recursiva:
Sabemos que dividir A por B é o mesmo que descobrir quantas vezes B cabe em A.
Assim, para dividir 18 por 4 podemos contar o no. de vezes que 4 cabe dentro de 18
DIV(18/4)= 1 + n° de vezes que b=4 cabe dentro de a=14 (18 - 4)
1 + 1 + n° de vezes que b=4 cabe dentro de a=10 (14 - 4)
1 + 1 + 1+ n° de vezes que b=4 cabe dentro de a=6 (10 - 4)
1 + 1 + 1 + 1 + n° de vezes que b=4 cabe dentro de a=2 (6-4)
Retorna 0
Retorna 1 1+ 0
Retorna 2 1 + 1
Retorna 3 1 + 2
Retorna 4 1 + 3
Exemplo-1 - solução
Condições de parada:
Se b=1 retorna a (opcional)
Se a < b retorna 0
Exemplo 2 - Solução
#include <stdio.h>
int Divide(int a, int b) {
if (b == 1) return a;
else if (a<b) return 0;
else return 1 + Divide(a-b,b);
}
int main(){
int a, b, resultado;
printf("forneca valores para a e b: ");
scanf("%d%d", &a, &b);
resultado=Divide(a,b);
printf("resultado=%d",resultado);
getch();
return 0;
}
Exemplo - 3
Exemplo 3 - solução
Escreva uma função recursiva para inverter uma linha
de texto.
Por exemplo, inverter a linha: TudoBem.
Condição de parada exibir o 1o. caractere: T posição 0
Parte recursiva:
exibir m e exibe_invertido(“TudoBe”)
exibir e e exibe_invertido(“TudoB”)
exibir B e exibe_invertido (“Tudo”)
exibir o e exibe_invertido (“Tud”)
exibir d e exibe_invertido(“Tu”)
exibir u e exibe_invertido(“T”)
Exibir T e parar
Nesse algoritmo a função não retorna
nada, pois já exibe o caractere.
Exercício – 1
void Exibe_invertido(char mensagem[], int tamanho) {
if (tamanho >= 0) {
printf("%c ", mensagem[tamanho]);
Exibe_invertido(mensagem,tamanho-1);
}
}
int main(){
char mensagem[10];
int tamanho;
printf("forneca a mensagem: ");
scanf("%s", mensagem);
tamanho=strlen(mensagem)-1;
Exibe_invertido(mensagem, tamanho);
getch();
return 0;
}
Exercício 1 - Solução
Escreva uma função recursiva para somar os elementos
de um array.
Por exemplo, seja V=[11, 2, 3, 14,15] e N=5
Parte recursiva:Seja n=N-1
#include <stdio.h>
int Soma_elementos(int V[], int n){
if (n ==0) return V[n];
else return (V[n]+ Soma_elementos(V, n-1));
}
int main() {
int i, N;
int V[80];
printf("entre com a quantidade de numeros--> ");
scanf("%d", &N);
printf("entre com os numeros--> ");
for (i=0; i<N;i++) scanf("%d", &V[i]);
printf("resultado=%d", Soma_elementos(V,N-1));
getch();
return 0;
}
Soma= 15 + Soma (V[11, 2, 3, 14]) n=4
14 + Soma (V[11, 2, 3]) n=3
3 + Soma(V[11,2]) n=2
2 + Soma(V[11]) n=1
n=0 Condição de parada
retorna 11
retorna 13
retorna 16
retorna 30
retorna 45
Exercício -2
Exercício-2 Solução (esquema1)
int max_array (int v[], int n){
int x;
if (n == 1) return v[0];
else {
x = max_array (v, n-1); /* máximo de v[0..n-2] */
if (x > v[n-1]) return x;
else return v[n-1];
}
}
Escreva uma função recursiva para encontrar o
maior elemento de um array
Modo recursivo- Um esquema:
O máximo de um array é o maior entre o último e o restante.
Quando houver apenas um elemento, este é o máximo.
3
1
4
5
2
3
1
4
3
1
4
5
5
2
2
3
1
4
3
1
3
3
3
3
1
4
5
5
int main() {
int i, N;
int V[80];
printf("entre com a quantidade de numeros--> ");
scanf("%d", &N);
printf("entre com os numeros--> ");
for (i=0; i<N;i++) scanf("%d", &V[i]);
printf("resultado=%d", max_array(V,N));
return 0;}
Exercício -2
Exercício-2 Solução (esquema 2)
Escreva uma função recursiva para encontrar o
maior elemento de um array
Modo recursivo- Outro esquema:
O máximo de um array é o maior entre os máximos de dois subarrays. Quando houver apenas um elemento, este é o máximo.
3
1
4
3
1
4
5
2
5
2
3
1
3
3
1
1
3
4
4
4
5
5
2
2
5
5
Exercício-2 Solução (cont)
int main() {
int i, N, inicio, fim;
int V[80];
printf("entre com a quantidade de numeros--> ");
scanf("%d", &N);
printf("entre com os numeros--> ");
for (i=0; i<N;i++)
scanf("%d", &V[i]);
inicio=0; fim=N-1;
printf("resultado=%d", max_array(V,inicio, fim));
getch();
return 0;
}
int max_array(int array[], int a, int b) {
int mid, num, x,y;
if (a == b)
return array[a]; /*Condição de parada */
else {int mid = (a+b)/2;
x= max_array(array, a, mid);
y= max_array(array, mid+1, b);
if(x>y) return x;
else return y;
}
}
int main() {
int i, N, inicio, fim;
int V[80];
printf("entre com a quantidade de numeros--> ");
scanf("%d", &N);
printf("entre com os numeros--> ");
for (i=0; i<N;i++) scanf("%d", &V[i]);
inicio=0; fim=N-1;
printf("resultado=%d", max_array(V,inicio, fim));
return 0;}