Parte 1 - Recursividade e Vetores

Recursividade

      Em uma forma simples de se explicar, recursividade é quando um método, ou função, invoca a si mesmo. Ela é usada para dividir o problema em subproblemas do mesmo tipo.

     Algumas das vantagens de se usar a recursividade são que ela oferece um código simplificado e mais elegante, porém em questão de processamento e uso da memória ele se torna mais dispendioso se quando comparado à solução iterativa.

     Um exemplo de caso simples que cabe muito bem ao uso da recursividade é o cálculo de uma fatorial de n (n!). Por exemplo, a fatorial de 5 é 120, pois 5 * 4 * 3 * 2 * 1 = 120.

     Sobre o fatorial, podemos observar, também, que 5! = 5 * 4!, 4! = 4 * 3!, e assim por diante. Com esta simples análise, pode-se ver que a fatorial de n será igual a esse n multiplicado por (n-1) fatorial, até que esse n atinja o número 0, onde seu valor será igual a 1.

Um método que faria a resolução desse problema de forma recursiva poderia ser escrito da seguinte forma:

int factorial(int n) {

      if (n <= 1)

            return 1;

      else

            return n * factorial(n - 1);

}

A imagem abaixo mostra a visão que se tem no momento que é chamado um método recursivo de fatorial, sendo que o argumento inicial de entrada foi o número 3.

Alguns dos problemas que podem acontecer com o uso incorreto da recursividade são:

• O Loop infinito, onde o programador teve o entendimento inadequado do caso e por isso não tem condição de parada;
• Falha de segmentação, onde acontece um acesso indevido à memória;
• Estouro de pilha, que pode ocorrer com múltiplas chamadas;
•  A complexidade para entender "quando o uso da recursividade é ideal ou necessário".

Vetores 

     Vetores, ou Arrays, são estruturas de dados presentes na maioria das linguagens de programação que permitem o armazenamento de várias variáveis de um mesmo tipo ou objetos de uma mesma classe usando apenas uma única referência e um índice de acesso (o primeiro índice é indexado como 0). É como se existisse uma caixa (um vetor) onde seu interior é dividido em várias outras caixinhas (índices do vetor).

Como exemplo, imagine que você deve guardar o valor das temperaturas dos 365 dias do ano em uma classe. Claramente usar uma variável para cada medida seria totalmente inviável. O problema seria bastante simplificado se somente um nome único fosse dado às variáveis e índices fossem usados para diferenciar as diferentes medidas.

     Os arrays podem ser unidimensionais, cujos elementos podem ser acessados por um único índice, ou também podem ser arrays multidimensionais, que são os que possuem mais de um índice para acessar determinado elemento. Um exemplo de vetor multidimensional é uma matriz matemática, onde os valores podem ser acessados especificando uma linha e uma coluna, que serão os índices usados.

A declaração de um array bem simples em Java poderia ser feito da seguinte forma:

public class ArrayDemo {
     public static void main(String[] args) {
         

int[] meuArray;                   // declara um array de inteiros

meuArray = new int[10];           // aloca a memória para 10 inteiros

     }
}

     Depois de declarado, posso inicializar o valor de cada parte do vetor, lembrando que o primeiro índice é o de 0:

meuArray[0] = 3;

meuArray[1] = 7;

meuArray[5] = 2;

    Um array depois de inicializado não pode ter seu tamanho modificado, embora possamos usar a referencia para apontar para outro array.

boolean[] respostas = new boolean[12];

respostas = new boolean[144];

     Desta forma as declarações estarão corretas, mas o valores do primeiro array (de 12 posições) serão perdidos quando a referencia apontar para o array de 144 posições.