-
Tem alguns assuntos no mundo
da programação
-
que quando a gente aprende,
a nossa cabeça dá cambalhota.
-
E recursão ou recursividade
é um desses assuntos.
-
Mas pode ficar tranquilo,
pode ficar tranquila,
-
porque muito mais importante
do que a gente descobrir
-
todos os problemas do mundo
-
que poderiam ser resolvidos
com recursividade,
-
é importante a gente entender
o funcionamento
-
e o porquê dessa estratégia.
-
Recursividade é basicamente quando
uma função chama a ela mesma.
-
É exatamente isso que você escutou.
-
Quando eu tenho um código,
onde uma função,
-
lá no meio das linhas dela,
está chamando a si própria.
-
Eu sei que parece uma coisa confusa,
esquisita e até desnecessária,
-
mas, na verdade,
a gente tem muitos exemplos
-
do por que isso seria preciso.
-
Imagine que você tem na sua casa
aquela famosa gaveta da bagunça,
-
aquela gaveta que é uma curva de rio
-
e a gente vai jogando tudo
que não sabe onde guardar dentro dela.
-
E aí, nós criamos uma função
chamada organizar.
-
E quando a gente abre essa gaveta,
nós vamos ativar a função organizar.
-
Só que a primeira coisa que a gente
encontra lá dentro é uma caixa.
-
E aí, eu teria duas alternativas
diferentes.
-
Eu poderia criar uma função
para organizar a gaveta
-
e ignorar o que eu encontrasse
dentro dela,
-
ou eu tenho a recursividade.
-
Eu posso estabelecer a seguinte regra,
-
ao encontrar uma caixa,
-
pare um pouco a execução da função
organizar da gaveta
-
e chame novamente a função organizar
para a caixa.
-
Isso é recursividade,
porque dentro da função organizar
-
eu tenho uma chamada
para a própria função organizar.
-
E aí, seguindo nesse exemplo,
imagina que dentro dessa caixa
-
eu tenha ainda
uma outra caixa guardada lá.
-
O que eu vou fazer?
-
Chamar de novo a função organizar
para essa caixa menor.
-
E isso vai se repetindo.
-
Essa chamada à função organizar
vai acontecendo
-
mais e mais e mais vezes
-
até que aconteça algo
muito importante.
-
O que a gente chama de critério
de parada.
-
Quando a minha função
vai parar de chamar a si mesma?
-
Quando ela vai poder retornar
algo concreto?
-
Eu posso estabelecer
como critério de parada
-
para esse meu exemplo,
eu ter organizado aquele espaço.
-
Então, eu chamei a função organizar
para a minha gaveta,
-
chamei novamente para a minha caixa,
-
chamei de novo
para a minha caixa menor,
-
quando eu tiver a minha caixa menor
devidamente organizada,
-
eu posso simplesmente terminar
essa execução e voltar para a anterior.
-
E aí eu termino de organizar
aquela caixa intermediária.
-
E aí eu termino de organizar
a minha gaveta.
-
A recursividade
já faz parte de tarefas
-
que a gente realiza dia após dia.
-
E pode ser um pouco estranho começar
a pensar em traduzir isso para código.
-
Inclusive,
recursividade não é a resolução
-
de todos os problemas do mundo.
-
Por que você percebeu
que eu vim falando
-
que a gente interrompia uma execução
-
para começar uma nova chamada à função?
-
Isso faz
com que o nosso sistema operacional
-
precise empilhar
esse monte de chamadas.
-
E é óbvio que uma hora
isso vai ser impossível,
-
porque não tem mais espaço em memória.
-
É aí que acontece o famoso estouro de pilha.
-
É o nosso sistema falando,
-
meu amigo,
minha amiga,
-
não dá para continuar brincando
com esse monte de chamadas de função,
-
eu simplesmente
vou crachar o programa,
-
eu vou encerrar ele,
e aí acabou com a sua brincadeira.
-
Apesar da recursão
ou da recursividade
-
não ser sempre a melhor saída
para resolver um problema,
-
em alguns casos
é a única saída possível.
-
Como até mesmo percorrer um texto
procurando determinados elementos.
-
Por isso,
existe um detalhe muito importante
-
na sua jornada de pessoa desenvolvedora,
-
que é entender
os princípios da recursão,
-
para que quando chegar a hora
de você precisar aplicar
-
em algum problema,
tudo já esteja no lugar certo.
