public static String decParaBin(int n) {
// Caso base: se o número for 0 ou 1, retorna o próprio número.
if (n <= 1) {
return Integer.toString(n);
} else {
// Caso recursivo:
// 1. Calcula o resto da divisão por 2 (o bit binário).
// 2. Chama a função recursivamente com o quociente da divisão.
// 3. Concatena o resto à direita do resultado da chamada recursiva.
return decParaBin(n / 2) + (n % 2);
}
}
public static void main(String[] args) {
int numeroDecimal = 14; // Exemplo de número decimal a ser convertido
String binario = decParaBin(numeroDecimal);
System.out.println("O número decimal " + numeroDecimal + " em binário é: " + binario); // Saída: O número decimal 14 em binário é: 1110
}
}
Como funciona ? Recursivo é pilha inverte? Como calcula o resultado é de cima para baixo? Da esquerda para a direita?
Exemplo passo a passo com o número 14:
decParaBin(14) chama decParaBin(7) e espera o resto 14 % 2 = 0
decParaBin(7) chama decParaBin(3) e espera o resto 7 % 2 = 1
decParaBin(3) chama decParaBin(1) e espera o resto 3 % 2 = 1
O que queres dizer com “inverte a execução”? O primeiro decParaBin que vai ser completado é o de 1, sim, mas isso não quer dizer que esse foi o primeiro a ser iniciado. A execução é efetuado “normalmente” de cima para baixo, mas fica, como dizes no teu exemplo, à espera de outras chamadas para completar.
Experimenta colocar logs, talvez ajude:
public static String decParaBin(int n) {
System.out.println("Chamada: decParaBin(" + n + ")");
// Caso base: se o número for 0 ou 1, retorna o próprio número.
if (n <= 1) {
System.out.println("→ Caso base atingido com n = " + n + ", retorna: " + n);
return Integer.toString(n);
} else {
int resto = n % 2;
int quociente = n / 2;
System.out.println("→ n = " + n + ", quociente = " + quociente + ", resto = " + resto);
String resultadoParcial = decParaBin(quociente);
System.out.println("← Recebido " + resultadoParcial + " que vou juntar ao resto " + resto);
String resultadoFinal = resultadoParcial + resto;
System.out.println("← Retorno de decParaBin(" + n + "): " + resultadoFinal);
return resultadoFinal;
}
}
Ouput:
Chamada: decParaBin(14)
→ n = 14, quociente = 7, resto = 0
Chamada: decParaBin(7)
→ n = 7, quociente = 3, resto = 1
Chamada: decParaBin(3)
→ n = 3, quociente = 1, resto = 1
Chamada: decParaBin(1)
→ Caso base atingido com n = 1, retorna: 1
← Recebido 1 que vou juntar ao resto 1
← Retorno de decParaBin(3): 11
← Recebido 11 que vou juntar ao resto 1
← Retorno de decParaBin(7): 111
← Recebido 111 que vou juntar ao resto 0
← Retorno de decParaBin(14): 1110
Não, ele “inverte” porque o código diz que é pra fazer assim.
Por exemplo, ao fazer decParaBin(7) + (14 % 2), ele precisa concatenar duas coisas:
o resultado de decParaBin(7)
o resultado de 14 % 2
O primeiro é uma chamada recursiva, então ele vai fazendo as outras chamadas (decParaBin(3) + (7 % 2), etc), e no final ele pega esse resultado e concatena com o resultado de 14 % 2 (que é zero). Por isso que o zero fica no final.
É assim:
decParaBin(14): retorna o resultado de decParaBin(7) concatenado com o resultado de 14 % 2
decParaBin(7): retorna o resultado de decParaBin(3) concatenado com o resultado de 7 % 2
decParaBin(3): retorna o resultado de decParaBin(1) concatenado com o resultado de 3 % 2
decParaBin(1): retorna 1 (caso base)
decParaBin(3): o resultado de decParaBin(1) é 1, concatenado com o resultado de 3 % 2 (que é 1), retorna 11
decParaBin(7): o resultado de decParaBin(3) é 11, concatenado com o resultado de 7 % 2 (que é 1), retorna 111
decParaBin(14): o resultado de decParaBin(7) é 111, concatenado com o resultado de 14 % 2 (que é 0), retorna 1110
