A sequência de Fibonacci é uma série de números onde cada número é a soma dos dois anteriores, começando geralmente com 0 e 1. Essa sequência tem aplicações em matemática, ciência da computação e até em fenômenos naturais. Vamos explorar a sequência de Fibonacci em Java, como gerar essa sequência em Java usando diferentes abordagens.

O que é a sequência de Fibonacci?

A sequência de Fibonacci é definida da seguinte forma:

• F(0) = 0
• F(1) = 1
• F(n) = F(n-1) + F(n-2) para n > 1

Os primeiros termos da sequência são: 0, 1, 1, 2, 3, 5, 8, 13, ...

Abordagem 1: Usando um loop para calcular Fibonacci

Essa é uma forma eficiente e direta de gerar a sequência até um certo número de termos, usando um loop for.

public class FibonacciLoop {
    public static void main(String[] args) {
        int n = 10; // Quantidade de termos a serem exibidos
        int primeiro = 0, segundo = 1;

        System.out.print("Sequência de Fibonacci com " + n + " termos: ");
        for (int i = 1; i <= n; i++) {
            System.out.print(primeiro + " ");

            int proximo = primeiro + segundo;
            primeiro = segundo;
            segundo = proximo;
        }
    }
}

Saída:

Sequência de Fibonacci com 10 termos: 0 1 1 2 3 5 8 13 21 34

Abordagem 2: Usando recursão para calcular Fibonacci

A recursão é uma forma mais intuitiva de implementar a sequência de Fibonacci, mas é menos eficiente, pois recalcula muitos valores desnecessariamente.

public class FibonacciRecursivo {
    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        int n = 10;
        System.out.print("Sequência de Fibonacci com " + n + " termos: ");
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacci(i) + " ");
        }
    }
}

Saída esperada:

Sequência de Fibonacci com 10 termos: 0 1 1 2 3 5 8 13 21 34

Observação: A recursão funciona bem para pequenos valores de n, mas se n for grande, o tempo de execução aumenta exponencialmente, pois a função fibonacci() é chamada repetidamente para os mesmos valores.

Abordagem 3: Usando programação dinâmica (memorização)

Para melhorar a eficiência da abordagem recursiva, podemos armazenar os resultados calculados (memorização), evitando recalcular valores.

public class FibonacciDinamico {
    private static int[] memo;

    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }

        // Verifica se o valor já foi calculado
        if (memo[n] != 0) {
            return memo[n];
        }

        // Calcula e armazena o resultado
        memo[n] = fibonacci(n - 1) + fibonacci(n - 2);
        return memo[n];
    }

    public static void main(String[] args) {
        int n = 10;
        memo = new int[n + 1]; // Cria array para memorização

        System.out.print("Sequência de Fibonacci com " + n + " termos: ");
        for (int i = 0; i < n; i++) {
            System.out.print(fibonacci(i) + " ");
        }
    }
}

Saída esperada:

Sequência de Fibonacci com 10 termos: 0 1 1 2 3 5 8 13 21 34

Outro exemplo prático

Código recursivo:

 public class Fibonacci {
    static long fibo(int n) {
    if (n < 2) {
      return n;
    } else {
      	//soma dos dois antecessores de 'n'            
        return fibo(n - 1) + fibo(n - 2);
      }
    }
 
    public static void main(String[] args) { 
	
    // imprime os 30 primeiros termos        
	for (int i = 0; i < 30; i++) {
      System.out.print(Fibonacci.fibo(i) + ", ");
    } 
  } 
}

	// Código iterativo:

 public class FibonacciIterativo { 
  public static long fibonacci(int n){
  int i = 1;
  int j = 0;
  int t;
  
  for(int k = 1; k <= n; k++){
   t = i + j;
   i = j;
   j = t;
  }
  return j;
 }
  
 public static void main(String[] args) {
   System.out.printf("%d", fibonacci(10));// imprime os 10 primeiros termos   
 } 
}

Cada abordagem tem suas vantagens e desvantagens. Usar um loop é a forma mais eficiente e direta.

A abordagem recursiva com memorização, ou programação dinâmica, é ideal para casos em que a recursão é necessária, mas também é eficiente o suficiente para valores maiores de n.

Dúvidas ou sugestões sobre a sequência de Fibonacci em Java? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: finonacci java