Algoritmo para hallar el menor numero dentro de un vector

[llAudioslavell]

Lo desarrolle yo mismo sin ver otros ejemplos y funciona muy bien, solo quisiera saber su opinión osea si es aceptable o aun se puede mejorar en algo

        int[] vector = {3,8,0};
        int rest=0; //resultado
        int n1=0;       
        int cont=0;
       
        for(int n=0; n<vector.length; n++){
            if (vector[n1]<vector[n]){
                cont++;
            }
            if (n==2){
                if (cont==2){
                    rest= vector[n1];
                }else{
                    n1++;
                    n=0;
                }           
               
            }
        }
        System.out.println(rest);

[ernestoch]

esta bien, lo simplifique un poco ...

Código: [Seleccionar]

        int[] vector = {3,8,0};
        int rest=vector[0]; //resultado
        for(int n=1; n<vector.length; n++){
            if (vector[n]<rest){
                rest = vector[n];
            }
        }
        System.out.println(rest);
nota que le reduje dos delcaraciones de variables y elimine todo un if, es decir, lo simplifiqué....
por supuesto que eventualmente podrias encapsular tu código en un método, pero funciona bien como dijiste.

EDIT: inicialicé n con 1 pues no tiene sentido comparar el elemento en la posición cero con el mismo.

[llAudioslavell]

esta bien, lo simplifique un poco ...

Código: [Seleccionar]

        int[] vector = {3,8,0};
        int rest=vector[0]; //resultado
        for(int n=1; n<vector.length; n++){
            if (vector[n]<rest){
                rest = vector[n];
            }
        }
        System.out.println(rest);
nota que le reduje dos delcaraciones de variables y elimine todo un if, es decir, lo simplifiqué....
por supuesto que eventualmente podrias encapsular tu código en un método, pero funciona bien como dijiste.

EDIT: inicialicé n con 1 pues no tiene sentido comparar el elemento en la posición cero con el mismo.

ya entendi en donde esta mi error... me rio de mi algoritmo  Muchas gracias !!!!!

[llAudioslavell]

Un mejor ejemplo, inmediatamente compilable.

Usa el valor +Infinity en lugar de simplemente 0 para encontrar el menor valor de forma más acorde a las operaciones matemáticas:


MenorNumeroDouble.java

Código: [Seleccionar]

class MenorNumeroDouble
{
   public static void main(String[] args)
   {
    //Valores de muestra:
    ///
     double[] vector = {3.3, 8.1, 0.7, -5.1, 3.4, 8.93, -2.07};




     System.out.println("Valor menor: "+encontrarMenor(vector));
   }






   public static double encontrarMenor(double [] v)
   {
    //Resultado. Inicializado a
    //Infinito Positivo, que es el máximo valor
    //posible, bueno para encontrar el menor número,
    //sea positivo, 0 o negativo.
    ///
     double Infinity = 1.0 / 0.0;
     double rest = (+Infinity);


    //Cachear la longitud del arreglo con la intención
    //de acceder menos propiedades y optimizar el código:
    ///
     int vl=v.length;
 

    //Iteramos por todos los elementos del arreglo:
    ///
      for(int n=1; n<vl; n++)
      {
        //Si encontramos un resultado menor al actual
        //originalmente (+Infinity), actualizamos ese valor:
        ///
         if (v[n]<rest)
         {
            rest = v[n];
         }
      }

    return rest;
   }
}

O usamos BigDecimal, para máxima precisión:

MenorNumeroBigDecimal.java

Código: [Seleccionar]

import java.math.BigDecimal;



class MenorNumeroBigDecimal
{
   public static void main(String[] args)
   {
    //Valores de muestra:
    ///
     BigDecimal[] vector = {
                      new BigDecimal(3.3),
                      new BigDecimal(8.1),
                      new BigDecimal(0.7),
                      new BigDecimal(-5.1),
                      new BigDecimal(3.4),
                      new BigDecimal(8.93),
                      new BigDecimal(-2.07)
                     };




     System.out.println("Valor menor: "+encontrarMenor(vector));
   }






   public static BigDecimal encontrarMenor(BigDecimal [] v)
   {
    //Resultado. Inicializado a
    //Infinito Positivo, que es el máximo valor
    //posible, bueno para encontrar el menor número,
    //sea positivo, 0 o negativo.
    ///
     double Infinity = 1.0/0.0;
     BigDecimal rest = new BigDecimal((long)+Infinity);


    //Cachear la longitud del arreglo con la intención
    //de acceder menos propiedades y optimizar el código:
    ///
     int vl=v.length;
 

    //Iteramos por todos los elementos del arreglo:
    ///
      for(int n=0; n<vl; n++)
      {
        //Si encontramos un resultado menor al actual
        //originalmente (+Infinity), actualizamos ese valor:
        ///
         if (v[n].compareTo(rest)<0)
         {
            rest = v[n];
         }
      }

    return rest;
   }
}

La verdad.... no entendi 
Voy a tratar de comprenderlo