SCJA
View more presentations from Rafael Sakurai.
Domingo, Dezembro 20, 2009
Sexta-feira, Setembro 18, 2009
Sexta-feira, Abril 10, 2009
Palestra - UML: Criando diagramas eficientes
Esses dias participei do evento SESTINFO/2009 da Universidade Metodista de São Paulo, este evento são alguns dias com diversas palestras e mini-cursos sobre tecnologia.
UML - Criando Diagramas Eficientes
View more presentations from Rodrigo Cascarrolho.
Quarta-feira, Dezembro 31, 2008
Framework, IDE e blablabla
É pessoal, mais um ano se passou, e a cada momento uma tecnologia nova surge.
Nesse ano usei bastante JSF, AJAX, JPA, EJB 3, infelizmente tive que terminar um projeto usando Struts 1 e usei varios bancos de dados diferentes Oracle, DB2, AS400, SQLServer e MySQL.
Uma combinação interessante para camada web foi utilizar JSF + Facelets + RichFaces, facilita bastante a criação das páginas, tive que criar uma coisa ou outra personalizada, mas grande parte já estava pronto das APIs, tem plug-in para o Eclipse de JSF e RichFaces para quem gosta de desenhar telas arrastando e soltando, mas prefiro ainda fazer na mão mesmo, da um pouco mais de trabalho, mas acho que aprendo mais também.
Montei um projeto utilizando NetBeans + Glassfish que ficou bem legal, facil integração com o servidor, NetBeans com JBoss ainda tenho um pouco mais de trabalho, não sei se é eu que não soube configurar direito mas o Hot Deploy não rola legal.
Falando em NetBeans aproveitei para tirar a Sun Certified Specialist NetBeans IDE, que era de GRATIS e já que faz algum tempo que eu uso o NetBeans. A versão 6.5 ficou bem legal reparei algumas alterações na parte do editor Java e curti bastante as alterações na parte de modelagem UML, acho que ficou bem mais simples criar diagramas UML.
Acho que só isso mesmo, e 2009 será bem corrido, varios projetos para desenvolver, varias tecnologias para estudar e Feliz 2009 para todos.
Nesse ano usei bastante JSF, AJAX, JPA, EJB 3, infelizmente tive que terminar um projeto usando Struts 1 e usei varios bancos de dados diferentes Oracle, DB2, AS400, SQLServer e MySQL.
Uma combinação interessante para camada web foi utilizar JSF + Facelets + RichFaces, facilita bastante a criação das páginas, tive que criar uma coisa ou outra personalizada, mas grande parte já estava pronto das APIs, tem plug-in para o Eclipse de JSF e RichFaces para quem gosta de desenhar telas arrastando e soltando, mas prefiro ainda fazer na mão mesmo, da um pouco mais de trabalho, mas acho que aprendo mais também.
Montei um projeto utilizando NetBeans + Glassfish que ficou bem legal, facil integração com o servidor, NetBeans com JBoss ainda tenho um pouco mais de trabalho, não sei se é eu que não soube configurar direito mas o Hot Deploy não rola legal.
Falando em NetBeans aproveitei para tirar a Sun Certified Specialist NetBeans IDE, que era de GRATIS e já que faz algum tempo que eu uso o NetBeans. A versão 6.5 ficou bem legal reparei algumas alterações na parte do editor Java e curti bastante as alterações na parte de modelagem UML, acho que ficou bem mais simples criar diagramas UML.
Acho que só isso mesmo, e 2009 será bem corrido, varios projetos para desenvolver, varias tecnologias para estudar e Feliz 2009 para todos.
Sexta-feira, Junho 27, 2008
Bubble Sort em Java
O Bubble-Sort é um dos algoritmos de ordenação mais simples.
O algoritmo consiste de percorrer os N elementos de um vetor, para cada vez percorrida, todos os elementos são comparados com o seu próximo, para verificar se estão na ordem desejada.
- Na primeira iteração, é encontrado o maior elemento e o mesmo é deslocado até a ultima posição.
- Na segunda iteração, é encontrado o segundo maior elemento e o mesmo é deslocado até a penúltima posição.
- Continua até que todos os elementos serem ordenados.
OBS: Não é obrigatório colocar sempre o maior elemento no final do vetor, dependendo da sua lógica de programação, é possível deixar os maiores elementos no começo e os menores elementos no final.
Implementação do Bubble Sort
Na linha 19 temos a assinatura do método que ordena um vetor de inteiros.
Na linha 21 temos um for para controlar a quantidade de vezes que esse vetor será ordenado, no caso (v.length – 1) vezes.
Na linha 23 temos um for para ordenar os elementos do vetor, este for irá ordenar (v.length – 1 – i) vezes. Na quantidade de vezes que o vetor é ordenado subtraímos pela quantidade de iterações que será realizada no caso a variável i, porque sabemos que quando uma iteração termina o ultimo elemento já está ordenado.
Na linha 26 verificamos se o valor da posição atual do vetor é maior que o próximo valor do vetor, se for maior trocamos os valores de lugar.
Uma forma melhorada do Bubble Sort:
Se repararmos na execução do Bubble Sort demonstrado no exemplo anterior, podemos perceber que se o vetor já estiver ordenado antes de chamar o método que ordena, será realizado as (v.length – 1) vezes iterações sobre ele e será comparado todos elementos dele para ver se está ordenado.
Podemos melhorar isso adicionando uma variável de controle que verifica se houve troca de valores no vetor, porque se durante uma iteração não houver nenhuma troca de valor, significa que o vetor já está ordenado.
Abaixo está a versão melhorada do Bubble Sort:
Na linha 23 foi criada uma variável boolean para controlar se o vetor está ordenado.
Na linha 32 se houve alguma troca de valor, então o vetor ainda não está totalmente ordenado, e a variável de controle é alterada para falso.
Na linha 36 se o vetor estiver ordenado então para a execução do for que controla a quantidade de vezes que o vetor será ordenado.
Exemplo de ordenação de vetor de objetos:
Neste exemplo temos uma classe Animal e cada animal tem uma especie e um nome.
A partir da classe animal, criamos um vetor de animais e queremos ordenar os animais pelo nome.
Segue abaixo a implementação do programa que ordena o vetor de animais utilizando o algoritmo de Bubble Sort.
Na linha 28 temos a assinatura do método que ordena um vetor de animais.
Na linha 30 temos um for para controlar a quantidade de vezes que esse vetor será ordenado, no caso (animais.length – 1) vezes.
Na linha 32 foi criada uma variável boolean para controlar se o vetor está ordenado.
Na linha 34 temos um for para ordenar os elementos do vetor, este for irá ordenar (animais.length – 1 – i) vezes. Na quantidade de vezes que o vetor é ordenado subtraímos pela quantidade de iterações que será realizada no caso a variável i, porque sabemos que quando uma iteração termina o ultimo elemento já está ordenado.
Na linha 37 verificamos se nome do animal da posição atual do vetor é maior que o nome do próximo animal do vetor, se for maior trocamos os animais de lugar.
Na linha 41 se houve alguma troca de animal, então o vetor ainda não está totalmente ordenado, e a variável de controle é alterada para falso.
Na linha 45 se o vetor estiver ordenado então para a execução do for que controla a quantidade de vezes que o vetor será ordenado.
Também podemos ordenar os animais pela espécie e depois pelo nome do animal:
Na linha 65 verifica se o nome da espécie do animal na posição atual do vetor é maior que o nome da espécie do próximo animal, se for então troca os animais de lugar.
Na linha 74 verifica se o nome da espécie do animal na posição atual do vetor é igual ao nome da espécie do próximo animal, se as espécies forem iguais, então verifica se o nome do animal na posição atual do vetor é maior que o nome do próximo animal, se for maior então troca os animais de lugar no vetor.
Bibliografia
Estrutura de Dados e Algoritmos em Java – Michal T. Goodrich e Roberto Tamassia
Algoritmos: Teoria e Prática – Thomas H. Cormen, Charles E. Leiserson, Ronald L.Rivest e Clifford Stein
Bubble Sort - http://pt.wikipedia.org/wiki/Bubble_sort
O algoritmo consiste de percorrer os N elementos de um vetor, para cada vez percorrida, todos os elementos são comparados com o seu próximo, para verificar se estão na ordem desejada.
Execução do algoritmo de Bubble Sort
- Na primeira iteração, é encontrado o maior elemento e o mesmo é deslocado até a ultima posição.
- Na segunda iteração, é encontrado o segundo maior elemento e o mesmo é deslocado até a penúltima posição.
- Continua até que todos os elementos serem ordenados.
OBS: Não é obrigatório colocar sempre o maior elemento no final do vetor, dependendo da sua lógica de programação, é possível deixar os maiores elementos no começo e os menores elementos no final.
Implementação do Bubble Sort
Na linha 19 temos a assinatura do método que ordena um vetor de inteiros.
Na linha 21 temos um for para controlar a quantidade de vezes que esse vetor será ordenado, no caso (v.length – 1) vezes.
Na linha 23 temos um for para ordenar os elementos do vetor, este for irá ordenar (v.length – 1 – i) vezes. Na quantidade de vezes que o vetor é ordenado subtraímos pela quantidade de iterações que será realizada no caso a variável i, porque sabemos que quando uma iteração termina o ultimo elemento já está ordenado.
Na linha 26 verificamos se o valor da posição atual do vetor é maior que o próximo valor do vetor, se for maior trocamos os valores de lugar.
Uma forma melhorada do Bubble Sort:
Se repararmos na execução do Bubble Sort demonstrado no exemplo anterior, podemos perceber que se o vetor já estiver ordenado antes de chamar o método que ordena, será realizado as (v.length – 1) vezes iterações sobre ele e será comparado todos elementos dele para ver se está ordenado.
Podemos melhorar isso adicionando uma variável de controle que verifica se houve troca de valores no vetor, porque se durante uma iteração não houver nenhuma troca de valor, significa que o vetor já está ordenado.
Abaixo está a versão melhorada do Bubble Sort:
Na linha 23 foi criada uma variável boolean para controlar se o vetor está ordenado.
Na linha 32 se houve alguma troca de valor, então o vetor ainda não está totalmente ordenado, e a variável de controle é alterada para falso.
Na linha 36 se o vetor estiver ordenado então para a execução do for que controla a quantidade de vezes que o vetor será ordenado.
Exemplo de ordenação de vetor de objetos:
Neste exemplo temos uma classe Animal e cada animal tem uma especie e um nome.
A partir da classe animal, criamos um vetor de animais e queremos ordenar os animais pelo nome.
Segue abaixo a implementação do programa que ordena o vetor de animais utilizando o algoritmo de Bubble Sort.
Na linha 28 temos a assinatura do método que ordena um vetor de animais.
Na linha 30 temos um for para controlar a quantidade de vezes que esse vetor será ordenado, no caso (animais.length – 1) vezes.
Na linha 32 foi criada uma variável boolean para controlar se o vetor está ordenado.
Na linha 34 temos um for para ordenar os elementos do vetor, este for irá ordenar (animais.length – 1 – i) vezes. Na quantidade de vezes que o vetor é ordenado subtraímos pela quantidade de iterações que será realizada no caso a variável i, porque sabemos que quando uma iteração termina o ultimo elemento já está ordenado.
Na linha 37 verificamos se nome do animal da posição atual do vetor é maior que o nome do próximo animal do vetor, se for maior trocamos os animais de lugar.
Na linha 41 se houve alguma troca de animal, então o vetor ainda não está totalmente ordenado, e a variável de controle é alterada para falso.
Na linha 45 se o vetor estiver ordenado então para a execução do for que controla a quantidade de vezes que o vetor será ordenado.
Também podemos ordenar os animais pela espécie e depois pelo nome do animal:
Na linha 65 verifica se o nome da espécie do animal na posição atual do vetor é maior que o nome da espécie do próximo animal, se for então troca os animais de lugar.Na linha 74 verifica se o nome da espécie do animal na posição atual do vetor é igual ao nome da espécie do próximo animal, se as espécies forem iguais, então verifica se o nome do animal na posição atual do vetor é maior que o nome do próximo animal, se for maior então troca os animais de lugar no vetor.
Bibliografia
Estrutura de Dados e Algoritmos em Java – Michal T. Goodrich e Roberto Tamassia
Algoritmos: Teoria e Prática – Thomas H. Cormen, Charles E. Leiserson, Ronald L.Rivest e Clifford Stein
Bubble Sort - http://pt.wikipedia.org/wiki/Bubble_sort
Quarta-feira, Maio 28, 2008
Recursividade - O inicio
Muitas pessoas quando começam a programar tem uma certa dificuldade em entender como funciona um método recursivo, mas creio eu que está dificuldade é mais em relação a “como” funciona a chamada de método.
Deste modo resolvi fazer mais um post bem simples, para tentar explicar aos iniciantes como funciona uma chamada de método.
Chamada de método
Quando um método precisa utilizar a funcionalidade de outro método, precisamos fazer com que um método chame outro método, no exemplo vamos criar um programa que imprima a soma dos números pares entre 1 e x (onde x é um número inteiro positivo).
Vamos criar um método main() que é por onde começa a execução do programa, depois vamos criar um método chamado imprimir() que irá somar os números pares entre 1 e x.
Na linha 4 foi criado o método main() por onde vai começar a execução do método.
Na linha 5 vamos imprimir a frase "Inicio do programa.".
Na linha 6 é criado um objeto da classe ImprimirPares para podermos chamar o método imprimir() dessa classe.
Na linha 7 chama o método imprimir() passando o valor 5 como parâmetro. Quando a execução do programa chega nesta linha o método imprimir() é chamado e a execução do método vai para a linha 12.
Da linha 12 a 17 temos o algoritmo que soma os números pares.
Na linha 19 imprime a soma dos números pares entre 1 e 5, ou seja, vai imprimir "Soma dos pares: 6".
Na linha 20 acaba o método imprimir(), agora a execução do programa volta para o método main(), pois foi ele que chamou o método imprimir(), repare também que a execução do método volta para a linha posterior a chamada do método, ou seja, vai para a linha 8.
Na linha 8 vamos imprimir a frase "Fim do programa.".
Na linha 9 acaba o método main() e encerra o programa.
Quando o programa é encerrado temos a seguinte saída no console:
Inicio do programa.
Soma dos pares: 6
Fim do programa.
Lembre-se: toda vez que um método termina sua execução, o fluxo de execução do programa volta para a linha posterior a qual ele foi chamada.
O mesmo é valido para quando um método chama ele mesmo, quando a execução do método terminar ele deve voltar para o mesmo método, só preste atenção pois o estado do método pode ser diferente para cada vez que ele se chama.
Mas o que isso quer dizer?
Os valores das variáveis passadas por parâmetro podem ser diferentes para cada vez que o método se chama, no exemplo abaixo vamos reescrever o método imprimir, mas agora vamos criar seu código de forma recursiva.
Antes de começar a escrever o código um método recursivo, precisamos pensar qual condição será interrompido a chamada recursiva, ou seja, quando o método precisa parar de se chamar.
Neste caso ele precisa parar a chamada do método quando terminarmos de percorrer o intervalo de 1 até x ou de x até 1.
Depois precisamos pensar no objetivo do método que é somar números pares.
Segue abaixo o código do método recursivo, o método ira somar os números pares de x até 1.
Na linha 7 chama o método imprimirRecursivo() passando o valor 5 como parâmetro. Quando a execução do programa chega nesta linha o método imprimirRecursivo() é chamado e a execução do método vai para a linha 11.
Na linha 11 declaramos o método recursivo, perceba que agora o método está retornando um número inteiro, dessa forma podemos calcular o valor da soma dos números pares e retornar este valor.
Na linha 13 verificamos se o valor de x é igual a 0 (zero), porque não queremos somar nenhum número menor que zero, e a soma do número 0 (zero) não irá alterar a resposta. Então se o valor de x for zero na linha 14 retorna o valor zero.
Na linha 18 verificamos se o valor de x é par, porque queremos somar apenas os números pares, e se for par então na linha 19 soma o valor de x com o valor do resultado da chamada recursiva do método imprimirRecursivo() passando como parâmetro x – 1.
A linha 23 será executada quando o valor de x for diferente de zero e também quando o número for impar.
Então teremos as seguintes chamadas de método:
O método main() vai chamar o método imprimirRecursivo(5), que por sua vez vai chamar o método imprimirRecursivo(4) até chegar no imprimirRecursivo(0), que irá parar as chamadas recursivas e volta para quem chamou ele passando o resultado da soma recursiva.
Se quiser também podemos melhorar um pouco este código, por exemplo quando encontrar o número par, chama o método recursivo para x – 2, pois assim só chamará o método para números pares.
Falows
Deste modo resolvi fazer mais um post bem simples, para tentar explicar aos iniciantes como funciona uma chamada de método.
Chamada de método
Quando um método precisa utilizar a funcionalidade de outro método, precisamos fazer com que um método chame outro método, no exemplo vamos criar um programa que imprima a soma dos números pares entre 1 e x (onde x é um número inteiro positivo).
Vamos criar um método main() que é por onde começa a execução do programa, depois vamos criar um método chamado imprimir() que irá somar os números pares entre 1 e x.
Na linha 4 foi criado o método main() por onde vai começar a execução do método.
Na linha 5 vamos imprimir a frase "Inicio do programa.".
Na linha 6 é criado um objeto da classe ImprimirPares para podermos chamar o método imprimir() dessa classe.
Na linha 7 chama o método imprimir() passando o valor 5 como parâmetro. Quando a execução do programa chega nesta linha o método imprimir() é chamado e a execução do método vai para a linha 12.
Da linha 12 a 17 temos o algoritmo que soma os números pares.
Na linha 19 imprime a soma dos números pares entre 1 e 5, ou seja, vai imprimir "Soma dos pares: 6".
Na linha 20 acaba o método imprimir(), agora a execução do programa volta para o método main(), pois foi ele que chamou o método imprimir(), repare também que a execução do método volta para a linha posterior a chamada do método, ou seja, vai para a linha 8.
Na linha 8 vamos imprimir a frase "Fim do programa.".
Na linha 9 acaba o método main() e encerra o programa.
Quando o programa é encerrado temos a seguinte saída no console:
Inicio do programa.
Soma dos pares: 6
Fim do programa.
Lembre-se: toda vez que um método termina sua execução, o fluxo de execução do programa volta para a linha posterior a qual ele foi chamada.
O mesmo é valido para quando um método chama ele mesmo, quando a execução do método terminar ele deve voltar para o mesmo método, só preste atenção pois o estado do método pode ser diferente para cada vez que ele se chama.
Mas o que isso quer dizer?
Os valores das variáveis passadas por parâmetro podem ser diferentes para cada vez que o método se chama, no exemplo abaixo vamos reescrever o método imprimir, mas agora vamos criar seu código de forma recursiva.
Antes de começar a escrever o código um método recursivo, precisamos pensar qual condição será interrompido a chamada recursiva, ou seja, quando o método precisa parar de se chamar.
Neste caso ele precisa parar a chamada do método quando terminarmos de percorrer o intervalo de 1 até x ou de x até 1.
Depois precisamos pensar no objetivo do método que é somar números pares.
Segue abaixo o código do método recursivo, o método ira somar os números pares de x até 1.
Na linha 11 declaramos o método recursivo, perceba que agora o método está retornando um número inteiro, dessa forma podemos calcular o valor da soma dos números pares e retornar este valor.
Na linha 13 verificamos se o valor de x é igual a 0 (zero), porque não queremos somar nenhum número menor que zero, e a soma do número 0 (zero) não irá alterar a resposta. Então se o valor de x for zero na linha 14 retorna o valor zero.
Na linha 18 verificamos se o valor de x é par, porque queremos somar apenas os números pares, e se for par então na linha 19 soma o valor de x com o valor do resultado da chamada recursiva do método imprimirRecursivo() passando como parâmetro x – 1.
A linha 23 será executada quando o valor de x for diferente de zero e também quando o número for impar.
Então teremos as seguintes chamadas de método:
Se quiser também podemos melhorar um pouco este código, por exemplo quando encontrar o número par, chama o método recursivo para x – 2, pois assim só chamará o método para números pares.
Falows
Segunda-feira, Maio 12, 2008
Recursividade em Java
Recursão é um método de programação no qual um função chama a si mesma.
A recursão é utilizada quando queremos resolver um subproblema do mesmo tipo menor.
Chamando um método dentro dele mesmo:
A chamada de um método para ele mesmo, é igual a chamada de qualquer outro método, exemplo de método recursivo que calcula o fatorial n!:
O fatorial de um número é dado pela multiplicação de seus antecessores, ou seja, se n é igual 3, então seu fatorial será 3 * 2 * 1. O fatorial de 0! (zero) é igual a 1.
O método recursivo fica da seguinte forma:
Dentro de um método recursivo é muito importante definirmos como será a condição base para que o método pare a recursão, ou seja, como o método vai parar de se chamar.
Neste caso queremos que o método para de chamar ele mesmo, quando o valor que será calculado o fatorial for igual a 0 (zero), pois neste caso sabemos a resposta direta sem ter que fazer cálculos.
Testando o método recursivo:
Chamando o método fatorial(3), queremos calcular 3 * 2 * 1.
-> 3 * fatorial(2) retorna (6)
-> -> 2 * fatorial(1) retorna (2)
-> -> -> 1 * fatorial(0) retorna (1)
Explicando o fluxo do programa:
1) O método fatorial recebe o valor de x igual a 3, verifica se x é igual a 0 (zero), como não é igual a 0 (zero), então calcula 3 multiplicado por fatorial(2), neste ponto estamos fazendo uma chamada recursiva.
2) O método fatorial recebe o valor de x igual a 2, verifica se x é igual a 0 (zero), como não é igual a 0 (zero), então calcula 2 multiplicado por fatorial(1).
3) O método fatorial recebe o valor de x igual a 1, verifica se x é igual a 0 (zero), como não é igual a 0 (zero), então calcula 1 multiplicado por fatorial(0).
4) O método fatorial recebe o valor de x igual a 0 (zero), verifica se x é igual a 0 (zero), então para a execução do método e retorna o valor 1.
5) Volta para o método fatorial(1) na linha 26 e faz a multiplicação de x que vale 1 pelo resultado do fatorial(0) que é 1, ou seja 1 * 1 e retorna o valor 1.
6) Volta para o método fatorial(2) na linha 26 e faz a multiplicação de x que vale 2 pelo resultado do fatorial(1) que é 1, ou seja 2 * 1 e retorna o valor 2.
7) Volta para o método fatorial(3) na linha 26 e faz a multiplicação de x que vale 3 pelo resultado do fatorial(2) que é 2, ou seja 3 * 2 e retorna o valor 6.
8) Volta para o método que chamou o fatorial(3), neste caso o método main na linha 7, guarda o resultado do fatorial(3) que é 6, dentro da variável resp, e imprime o resultado da variável resp na linha 8.
Outro exemplo de recursão: Ordem decrescente
Método recursivo que recebe um número x por parâmetro e imprime seu valor em ordem decrescente até 1.
Quando usamos recursão, precisamos definir o momento de parada, quando a função não deve ser mais chamada.
No caso do exemplo anterior queremos que o método não si chame novamente quando o x for igual a 0 (zero), porque queremos apenas os números entre [x ... 1]:
Agora precisamos definir o que nosso método deve fazer, neste caso deve imprimir o valor de x, e em seguida chama a si mesma diminuindo em 1 o valor de x.
A recursão é utilizada quando queremos resolver um subproblema do mesmo tipo menor.
- Se o problema é pequeno
- Então resolva o problema diretamente
- Senão
- Reduza o problema em um problema menor, chame novamente o método para o problema menor e volte ao problema original.
Chamando um método dentro dele mesmo:
A chamada de um método para ele mesmo, é igual a chamada de qualquer outro método, exemplo de método recursivo que calcula o fatorial n!:
O fatorial de um número é dado pela multiplicação de seus antecessores, ou seja, se n é igual 3, então seu fatorial será 3 * 2 * 1. O fatorial de 0! (zero) é igual a 1.
O método recursivo fica da seguinte forma:
Dentro de um método recursivo é muito importante definirmos como será a condição base para que o método pare a recursão, ou seja, como o método vai parar de se chamar.
Neste caso queremos que o método para de chamar ele mesmo, quando o valor que será calculado o fatorial for igual a 0 (zero), pois neste caso sabemos a resposta direta sem ter que fazer cálculos.
Testando o método recursivo:
Chamando o método fatorial(3), queremos calcular 3 * 2 * 1.-> 3 * fatorial(2) retorna (6)
-> -> 2 * fatorial(1) retorna (2)
-> -> -> 1 * fatorial(0) retorna (1)
Explicando o fluxo do programa:
1) O método fatorial recebe o valor de x igual a 3, verifica se x é igual a 0 (zero), como não é igual a 0 (zero), então calcula 3 multiplicado por fatorial(2), neste ponto estamos fazendo uma chamada recursiva.
2) O método fatorial recebe o valor de x igual a 2, verifica se x é igual a 0 (zero), como não é igual a 0 (zero), então calcula 2 multiplicado por fatorial(1).
3) O método fatorial recebe o valor de x igual a 1, verifica se x é igual a 0 (zero), como não é igual a 0 (zero), então calcula 1 multiplicado por fatorial(0).
4) O método fatorial recebe o valor de x igual a 0 (zero), verifica se x é igual a 0 (zero), então para a execução do método e retorna o valor 1.
5) Volta para o método fatorial(1) na linha 26 e faz a multiplicação de x que vale 1 pelo resultado do fatorial(0) que é 1, ou seja 1 * 1 e retorna o valor 1.
6) Volta para o método fatorial(2) na linha 26 e faz a multiplicação de x que vale 2 pelo resultado do fatorial(1) que é 1, ou seja 2 * 1 e retorna o valor 2.
7) Volta para o método fatorial(3) na linha 26 e faz a multiplicação de x que vale 3 pelo resultado do fatorial(2) que é 2, ou seja 3 * 2 e retorna o valor 6.
8) Volta para o método que chamou o fatorial(3), neste caso o método main na linha 7, guarda o resultado do fatorial(3) que é 6, dentro da variável resp, e imprime o resultado da variável resp na linha 8.
Outro exemplo de recursão: Ordem decrescente
Método recursivo que recebe um número x por parâmetro e imprime seu valor em ordem decrescente até 1.
Quando usamos recursão, precisamos definir o momento de parada, quando a função não deve ser mais chamada.
No caso do exemplo anterior queremos que o método não si chame novamente quando o x for igual a 0 (zero), porque queremos apenas os números entre [x ... 1]:
if(x == 0) return;
Agora precisamos definir o que nosso método deve fazer, neste caso deve imprimir o valor de x, e em seguida chama a si mesma diminuindo em 1 o valor de x.
System.out.println(x);
imprimirSequencia(x - 1);
A próxima vez que a função imprimirSequencia(int x) for chamada, o valor de x diminui 1 até chegar a 0 (zero) e parar a execução do código.
imprimirSequencia(x - 1);
A próxima vez que a função imprimirSequencia(int x) for chamada, o valor de x diminui 1 até chegar a 0 (zero) e parar a execução do código.
Bibliografia
Estrutura de Dados e Algoritmos em Java – Michal T. Goodrich e Roberto Tamassia
Algoritmos: Teoria e Prática – Thomas H. Cormen, Charles E. Leiserson, Ronald L.Rivest e Clifford Stein
Fatorial - http://pt.wikipedia.org/wiki/Fatorial
Recursão e algoritmos recursivos - http://www.ime.usp.br/~pf/algoritmos/aulas/recu.html
Assinar:
Postagens (Atom)
