Como funciona a recursão
Casos-base e a pilha de chamadas.
Como funciona a recursão é uma aula grátis de C Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.
O que é recursão?
Recursão ocorre quando uma função chama a si mesma para resolver um problema. Cada chamada trabalha com uma parte menor do problema original.
Em C, qualquer função pode chamar a si mesma, desde que exista uma forma de fazer as chamadas pararem.
O caso-base
Toda função recursiva precisa de um caso-base: uma condição na qual ela para de chamar a si mesma e retorna diretamente.
Sem um caso-base, a função chamaria a si mesma para sempre e faria o programa falhar.
int countdown(int n) {
if (n == 0) return 0; /* base case */
return countdown(n - 1);
}O caso recursivo
O caso recursivo é a parte em que a função chama a si mesma com um argumento alterado.
Esse argumento deve avançar em direção ao caso-base; caso contrário, a recursão nunca termina.
int sum_to(int n) {
if (n == 0) return 0; /* base case */
return n + sum_to(n - 1); /* recursive case */
}Um primeiro programa completo
Vamos executar um programa completo que soma os números de 1 a 5 usando recursão.
O resultado deve ser 15.
#include <stdio.h>
int sum_to(int n) {
if (n == 0) return 0;
return n + sum_to(n - 1);
}
int main(void) {
printf("%d\n", sum_to(5));
return 0;
}Rastreando as chamadas
É útil rastrear a recursão manualmente. Para sum_to(3):
sum_to(3) = 3 + sum_to(2)
sum_to(2) = 2 + sum_to(1)
sum_to(1) = 1 + sum_to(0)
sum_to(0) = 0
Em seguida, as chamadas retornam de volta: 1, depois 3 e, por fim, 6.
A pilha de chamadas
Cada chamada de função recebe seu próprio espaço na pilha de chamadas, onde ficam seus parâmetros e variáveis locais.
Ao avançar para níveis mais profundos, os quadros se acumulam. Quando uma chamada retorna, seu quadro é removido e o controle volta para quem fez a chamada.
Descida e retorno
A recursão tem duas fases. A descida ocorre quando as chamadas continuam avançando em direção ao caso-base.
O retorno ocorre quando o caso-base retorna e cada chamada conclui seu trabalho usando o valor retornado.
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
int main(void) {
printf("%d\n", factorial(4));
return 0;
}Os valores de retorno voltam
O valor retornado por uma chamada mais profunda é usado pela chamada que a fez.
Por isso, a ordem importa: a chamada mais profunda termina primeiro e, depois, os resultados são combinados no caminho de volta pela pilha.
int power(int base, int exp) {
if (exp == 0) return 1;
return base * power(base, exp - 1);
}Exibindo durante a recursão
Você pode exibir algo antes ou depois da chamada recursiva. Exibir antes mostra os números na descida; exibir depois mostra os números no retorno.
#include <stdio.h>
void down(int n) {
if (n == 0) return;
printf("%d ", n);
down(n - 1);
}
int main(void) {
down(5);
printf("\n");
return 0;
}Exibindo no caminho de volta
Mova o printf para depois da chamada recursiva, e a ordem será invertida. A chamada mais profunda exibirá seu resultado primeiro.
Isso exibe 1 2 3 4 5 em vez de 5 4 3 2 1.
#include <stdio.h>
void up(int n) {
if (n == 0) return;
up(n - 1);
printf("%d ", n);
}
int main(void) {
up(5);
printf("\n");
return 0;
}Duas regras para lembrar
Uma função recursiva correta segue duas regras:
1. Ela tem pelo menos um caso-base que retorna sem fazer recursão.
2. Cada chamada recursiva aproxima o argumento de um caso-base.
Se você violar qualquer uma das regras, o programa entrará em um loop infinito.
Verificação rápida
Teste sua compreensão dos fundamentos da recursão.
Recapitulação
A recursão resolve um problema chamando a si mesma com uma entrada menor. É sempre necessário ter um caso-base para parar e um caso recursivo que avance em direção a ele.
Cada chamada usa um quadro da pilha; os resultados voltam à medida que as chamadas retornam.
Perguntas Frequentes
A aula “Como funciona a recursão” é grátis?
Sim — o texto completo de “Como funciona a recursão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.
O que vou aprender em “Como funciona a recursão”?
Casos-base e a pilha de chamadas. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C Academy?
Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Como funciona a recursão”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C Academy?
Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Como funciona a recursão
- Problemas recursivos clássicos
- Recursão versus iteração
- Evitando estouro de pilha