Metodo recursivo

Programação Java
#1

Bom galera estou tentando por meio da recursividade criar um algoritmo q faça o seguinte tem um vetor desordenado e quero q ele apenas me traga o menor valor desse vetor no caso não precisaria ordenar.Quem puder me ajudar ficarei grato!!
Estou tentando dessa forma:


public static void main(String[] args) {   
  
        Main vet=new Main();   
        int[] veto = {5,3,2,4};   
        int tamanho=veto.length;   
  
       vet.vetor(veto, tamanho);   
  
       
    }   
      
      public int vetor(int veto[], int tamanho){   
        int menor=0 ;   
        int i=0;   
           
        System.out.println();   
        if (veto[i] < veto[i+1]){   
            menor=veto[i];   
            return vetor(veto, i++);   
        }   
            else if(veto[i]>veto[i+1]){   
                 menor = veto[i+1];   
                return vetor (veto,i++);   
  
            }   
            else if (veto[i]==tamanho){   
                return menor;   
  
        }   
        return menor;   
  
      }   
  
    }
#2 
int valorMax = 0;
for(int i=0;i<vector.size();i++){
 if(valorMax < vector.get(i)){
  valorMax = vector.get(i);
 }
}
//estará armazenado, o maior na variável.
#3

só uma duvida eu posso usar for na recursividade??

#4

Olá Villa,

Por que você não usa um método que use divisão e conquista? Acho que seria mais adequado e elegante para o que você quer fazer.
Abraços

#5

Olá! Evite duplicar tópicos:

Recursividade

#6

Ollá bFabri

é que na verdade isso seria um exercicio da facul entendeo só que no caso num intendi mto bem
o metodo recursividade gostaria q alguem pudesse me ajudar.

abraços

#7

Demorou Éder

foi mal aii
abraços

#8

Bem, antes de tudo numa recursão, precisa-se primeiramente definir qual será o ponto de para dela,
depois disso é só chama-la novamente e implementar o que deseja-se.

No seu caso você está querendo encontrar o menor valor de um vetor passado como parâmetro,
pois bem, o ponto de parada nesse caso será quando indice passado for igual a o (vetor.length -1)
é retornado o último valor do vetor que na volta da recursão será comparado como o anterior a ele,
e assim até terminar a recursão.

public static int menorValor(int[] vetor, int indice) {
     // definindo ponto de parada
     if ((vetor.length - 1) != indice) {
         int i_anterior = vetor[indice]; // pegando o valor anterior

         int i_proximo = menorValor(vetor, ++indice); // pegando o proximo valor

         // a cada comparação entre dois valores do vetor sempre é retornado
         // o menor valor, e isso segue-se até o fim da recursão
         return (i_anterior < i_proximo) ? i_anterior : i_proximo; 
     }

     return vetor[indice]; // retornando o último valor do vetor
}

Espero que tenha entendido a explicação, e não somente o código.

Até mais…

#9

Olá WendersonLP

vlw pela força brother, mais só num entendi uma coisa o que seria “?” e o “:” na linha 10 do seu algoritmo???

vlw abraços…

#10

Isso se chama operador ternário, você pode ler mais sobre em http://pt.wikipedia.org/wiki/Operação_ternária

A linha 10 pode ser escrita da seguinte forma:

if (i_anterior < i_proximo) return i_anterior; else return i_proximo;

#11

Acho que “nephestos” já explicou!

#12