como buscar los dos numeros mas grandes de un array?

[RIVERMILLOS]

Hola estoy haciendo un algoritmo para encontrar los dos numeros mas grandes de un array aplicando divide y venceras o recursividad ,hasta ahora lo que he hecho es
eliminar las posibilidades separando en grupos de a dos el array y enviando el mas grande del grupo a al derecha asi.

Código java:

for(int i=0;i<tamano;i=i+2){
         int aux;
         if(array_num[i]<array_num[i+2]){
         aux=array_num[i+2];
         array_num[i+2]=array_num[i];
         array_num[i]=aux;
         }
      }
 

pero no encuentro la forma de aplicar estos conceptos en este problema.

ayuda por favor.

saludos

[HackmanC]

Hola,

Iniciado por RIVERMILLOS

... aplicando divide y venceras o recursividad ...

¿Donde estas aplicando recursividad? En ese programa no se mira que exista recursividad. (Por si las dudas ... recursividad no es dividir un arreglo en dos y continuar dividiendo, es otro concepto muy diferente aplicado a llamadas a funciones o métodos)

Iniciado por RIVERMILLOS

... hasta ahora lo que he hecho es
eliminar las posibilidades separando en grupos de a dos el array y enviando el mas grande del grupo a al derecha asi. ...

¿Los estas ordenando o estas buscando el mayor?
Si solo estas buscando ... ¿para qué mueves de lugar el número?

Iniciado por RIVERMILLOS

... pero no encuentro la forma de aplicar estos conceptos en este problema. ...

Ese algoritmo no sería aconsejable resolverlo usando recursividad.
El método es simple, suponiendo que tienes esta lista de números:

6 5 2 4 9 8 7 3 1 0

¿Como sabes cual es el mayor y el anterior al mayor?

Inicializas una variable que sea el mayor con -1. Después tomas el 6, ¿es mayor al antiguo mayor, que era -1? Como verdaderamente es mayor entonces guardas en la variable mayor el 6. Después tomas el 5, ¿es mayor al antiguo mayor, que era 6? Como no es mayor entonces no haces nada. Y así continuas buscando el mayor.

Para buscar el anterior al mayor, vuelves a realizar el proceso pero sin tomar en cuenta el mayor que ya habías encontrado. Pero si lo quieres hacer eficientemente, solamente haces un ciclo donde se busque el mayor y el anterior al mayor, sino lo haces en dos pasadas.

Saludos,

[RIVERMILLOS]

Si tienes razon el algortimo como lo planteaste es muy facil me estaba complicando la vida , es que el algoritmo lo tengo que resolver usando divide y venceras.


saludos

[HackmanC]

Hola,

Bueno, ese algoritmo de dividir el arreglo en partes (búsqueda binaria) se usa para buscar un número cuando la lista ya está ordenada, pero no sirve para buscar el mayor si, lógicamente, la lista ya está ordenada. Si lo que estás haciendo es un ordenamiento es otra historia, y puedes buscar información sobre QuickSort.

Saludos,

[Flipis120]

Hola, yo tengo este código, que busca el máximo de un Array de forma recursiva.

Código:

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {



        int vector[] = {2, 1, 3, 9, 5, 6, 4, 8, 7};//Vector de numeros
        int max = 0;//Variable que contendrá el número
        max = mayorVector(vector);//Función Recursiva

        if (vector[vector.length - 1] > max) {              //Ultima Comprobación
            max = vector[vector.length - 1];
        }
        System.out.println("Del Vector:");
        for (int i = 0; i < vector.length; i++) {
            System.out.print(vector[i] + " ");
        }
        System.out.println("");
        System.out.println("El mayor es " + max);

    }

    public static int mayorVector(int vector[]) {

        int vector2[] = new int[vector.length - 1];         //Vector al que le voy quitando la última posición
        int max = 0;                                                      //Variable que recibirá de la función el máximo momentaneo

        for (int i = 0; i < vector2.length; i++) {              //Igualo los vectores
            vector2[i] = vector[i];
        }

        if (vector.length == 1) {                                       //Para de hacer recursión cuando solo quede una posición en el vector que se le pasa a la función
            max = vector[0];

        } else {
            max = mayorVector(vector2);

            if (max < vector[vector.length - 1]) {              //Si el max que se tiene es menor que el ultimo elemento del array se le asigna el valor
                max = vector[vector.length - 1];

            }
        }
        return max;
    }
}

Un saludo!

[HackmanC]

Hola,

Iniciado por Flipis120

Hola, yo tengo este código, que busca el máximo de un Array de forma recursiva. ...

¿Cual podría ser el objetivo de semejante algoritmo? Es completamente ineficiente, consume demasiada memora y es lento. Si lo que quieres aprender es cómo hacer un algoritmo recursivo, usa un ejemplo más eficiente, como una búsqueda en un árbol binario o cualquier otra cosa.

Código:

public class Main {

    int vector[] = {2, 1, 3, 9, 5, 6, 4, 8, 7};

    public static void main(String[] args) {
        new Main().BuscarMayor();
    }

    public void BuscarMayor() {
        int mayor = 0;
        for (int i = 0; i < vector.length; i++)
            if (vector[i] > mayor) mayor = vector[i];
        System.out.println("El mayor es : " + String.valueOf(mayor));
    }

}

No entiendo ... ¿podrías explicar por qué hacer un algoritmo tan ineficiente de algo que se puede resolver tan fácil? (Aparte de aplicar un paradigma de programación en donde no es adecuado)

Saludos,

[Flipis120]

Iniciado por HackmanC

Hola,



¿Cual podría ser el objetivo de semejante algoritmo? Es completamente ineficiente, consume demasiada memora y es lento. Si lo que quieres aprender es cómo hacer un algoritmo recursivo, usa un ejemplo más eficiente, como una búsqueda en un árbol binario o cualquier otra cosa.

Código:

public class Main {

    int vector[] = {2, 1, 3, 9, 5, 6, 4, 8, 7};

    public static void main(String[] args) {
        new Main().BuscarMayor();
    }

    public void BuscarMayor() {
        int mayor = 0;
        for (int i = 0; i < vector.length; i++)
            if (vector[i] > mayor) mayor = vector[i];
        System.out.println("El mayor es : " + String.valueOf(mayor));
    }

}

No entiendo ... ¿podrías explicar por qué hacer un algoritmo tan ineficiente de algo que se puede resolver tan fácil? (Aparte de aplicar un paradigma de programación en donde no es adecuado)

Saludos,

En ningun momento he dicho que sea el más eficiente, es un código que tenía por ahi y que quizá le ayude para ver cosas, nada mas, como he dicho no pretendo decir que es eficiente, de hecho cuando lo hice ni lo tuve en cuenta, y se que no es el paradigma adecuado para resolver este sencillo problema, yo directamente ordenaria y buscaria, pero es el que me toco usar en su momento xD, de todas formas yo lo explico y si tienes uno mas eficiente y lo quieres compartir te animo a que lo hagas.
Un saludo

[HackmanC]

Hola,

Iniciado por Flipis120

En ningun momento he dicho que sea el más eficiente, es un código que tenía por ahi y que quizá le ayude para ver cosas, nada mas, como he dicho no pretendo decir que es eficiente, de hecho cuando lo hice ni lo tuve en cuenta, y se que no es el paradigma adecuado para resolver este sencillo problema, yo directamente ordenaria y buscaria, pero es el que me toco usar en su momento xD, de todas formas yo lo explico y si tienes uno mas eficiente y lo quieres compartir te animo a que lo hagas.
Un saludo

Ya lo hice, es decir, el código que puse hace exactamente lo mismo pero seguramente mucho mas eficientemente, sin usar recursión, ni copias de vectores, usa 1,000 integers para buscar en 1,000 integers, como debe ser.

De hecho tu ejemplo posiblemente si es útil, ¿sabías que para buscar el mayor de 100 integers, tu algoritmo almacena 5050 integers, y para buscar en 1000 almacena 500500 integers? Sí, son dos megas nada más, pero el factor de almacenamiento aumentó en 2,002,000%.

Sabías que no te alcanzaría la memoria RAM de tu computadora para buscar el mayor en 100,000 números, para lo cual necesitarías aproximadamente 20 gigabytes. Eso solo es el consumo de memoria.

Bueno, seguramente algún motivo habrá que yo no puedo entender.

Saludos,

[Flipis120]

Iniciado por HackmanC

Hola,



Ya lo hice, es decir, el código que puse hace exactamente lo mismo pero seguramente mucho mas eficientemente, sin usar recursión, ni copias de vectores, usa 1,000 integers para buscar en 1,000 integers, como debe ser.

De hecho tu ejemplo posiblemente si es útil, ¿sabías que para buscar el mayor de 100 integers, tu algoritmo almacena 5050 integers, y para buscar en 1000 almacena 500500 integers? Sí, son dos megas nada más, pero el factor de almacenamiento aumentó en 2,002,000%.

Sabías que no te alcanzaría la memoria RAM de tu computadora para buscar el mayor en 100,000 números, para lo cual necesitarías aproximadamente 20 gigabytes. Eso solo es el consumo de memoria.

Bueno, seguramente algún motivo habrá que yo no puedo entender.

Saludos,

Vamos a ver, creo k no me has entendido, no te estoy discutiendo la eficiencia, te he dicho que no he tenido en cuenta la eficiencia para nada, la razon por la que tuve que hacer eso es porque cuando estudiaba java el profesor me pidió que lo hiciera asi, si comprendo que recorrer ir comparando numeros es mejor, no me malinterpretes te doy la razon en eso, no hace falta que me expongas los calculos, pero kmo dijo que lo podia hacer usando recursividad, yo lo puse nada mas, y ya no tengo nada mas que decir con respecto a esto xD, 1 Saludo!

[HackmanC]

Hola,

Iniciado por HackmanC

Bueno, seguramente algún motivo habrá que yo no puedo entender.

Iniciado por Flipis120

... la razon por la que tuve que hacer eso es porque cuando estudiaba java el profesor me pidió que lo hiciera asi, si comprendo que recorrer ir comparando numeros es mejor, no me malinterpretes te doy la razon en eso, ...

Ahora comprendo un poco más, pero tampoco está demás explicar el motivo por el cual está mal hacer un programa así, haciendo una analogía, ¿acaso usarías un tractor como medio de transporte para ir a trabajar todos los días, si tienes un compacto en la cochera?, lo mismo sucede con ese código.

Y todo hay que decirlo, no es para hacerte quedar mal en ningún momento, es para que cuando alguien sin conocimientos de programación venga a foros del web y mire ese programa, tenga claro y sin dudas que es algo que se puede hacer pero no es lo mas adecuado.

Saludos,

ps:

Iniciado por Flipis120

... Vamos a ver, creo k no me has entendido, ...

En eso si tenias toda la razón.

[Flipis120]

Okey HackmanC ahora estamos totalmente de acuerdo xD

Un saludo, un placer conversar contigo :)

[Chem0n]

Buenas, aqui dejo mi idea, por si puede ayudar, pero lo mejor es hacerlo uno mismo, para aprender y entrenar la mente, que es por eso por lo que nuestros profesores nos mandan este tipo de ejercicios en la facultad.
Esta claro que se puede hacer de una forma mas simple, pero nuestros profesores nos mandan los ejercicios para practicar y aprender algunos conceptos como la recursividad o el paso de parametros.

Con mi ejemplo te das cuenta como usar recursividad y que el paso de parametros para objetos de tipo no simple es por referencia.

Código:

public void NumMasGrandes(int[] vector, int[] numgran, int idx){
        // comprobamos que no hemos llegado al final del vector
        if ( idx < vector.length ){
            //inicializamos numgran con los dos primeros numeros del vector.
            //se sobreentiende que numgran es un array de 2 enteros.
            if ( idx < 2 ){
                numgran[0] = vector [0];
                numgran[1] = vector [1];
                NumMasGrandes(vector, numgran, idx+2);
            }else{
                if ( ( vector[idx]> numgran[0] ) && ( vector[idx]> numgran[1] )){
                    if ( numgran[0] < numgran[1] ){
                        numgran[0] = vector[idx];
                    }else{
                        numgran[1] = vector[idx];
                    }
                }else if ( vector[idx]> numgran[0] ){
                    numgran[0] = vector[idx];
                }else if ( vector[idx]> numgran[1] ){
                    numgran[1] = vector[idx];
                }else{
                }
                NumMasGrandes(vector, numgran, idx+1);
            }
        }
    }

Código:

        int vector[] = {0, 11, 11, 12, 11, 12, 1, 12, 13, 12, 11, 12, 8, 7};
        int numgran[] = new int[2];
        NumMasGrandes(vector, numgran, 0);
        System.out.println("Los dos valores mayores son "+numgran[0]+" y "+numgran[1]+".");

vector es el array a evaluar, numgran es un array de dimension 2 para almacenar los 2 numeros mas grandes e idx es el indice para recorrer el vector.

Si le pasamos numgran instanciado e inicializado ( es decir numgran[0] = -1 y numgran[1] = -1 ) el metodo todavia queda mas sencillo.

Código:

public void NumMasGrandes(int[] vector, int[] numgran, int idx){
        // comprobamos que no hemos llegado al final del vector
        if ( idx < vector.length ){
                if ( ( vector[idx]> numgran[0] ) && ( vector[idx]> numgran[1] )){
                    if ( numgran[0] < numgran[1] ){
                        numgran[0] = vector[idx];
                    }else{
                        numgran[1] = vector[idx];
                    }
                }else if ( vector[idx]> numgran[0] ){
                    numgran[0] = vector[idx];
                }else if ( vector[idx]> numgran[1] ){
                    numgran[1] = vector[idx];
                }else{
                }
                NumMasGrandes(vector, numgran, idx+1);
        }
    }

Código:

        int vector[] = {0, 11, 11, 12, 11, 12, 1, 12, 13, 12, 11, 12, 8, 7};
        int numgran[] = new int[2];
        numgran[0] = -1;
        numgran[1] = -1;
        NumMasGrandes(vector, numgran, 0);
        System.out.println("Los dos valores mayores son "+numgran[0]+" y "+numgran[1]+".");

Y aqui otra ejemplo bastante simple para buscar los X numeros mas altos en un array, simplemente declaramos un array de X de longitud ( en mi ejemplo es de longitud 4 pero puede ser de cualquier longitud ) y ya esta y se lo pasamos a la funcion NumMasGrandes2

Código:

public int IdxNumMasPequeño(int[] auxvec, int idx, int idxpeq){
        if ( idx < auxvec.length ){
            if ( auxvec[idx] < auxvec[idxpeq])
                idxpeq = idx;
            return ( IdxNumMasPequeño( auxvec, idx+1, idxpeq ) );
        }else
            return idxpeq;
     }

public void NumMasGrandes2(int[] vector, int[] numgran, int idx){
        // comprobamos que no hemos llegado al final del vector
        if ( idx < vector.length ){
            //inicializamos numgran con los primeros valores de vector
            if ( idx == 0 ){
                for (int i=0;i<numgran.length;i++)
                    numgran[i] = vector [i];
                NumMasGrandes2(vector, numgran, (idx+numgran.length));
            }else{
                int idxnummaspeq = IdxNumMasPequeño(numgran, 0, 0);
                if ( vector[idx] > numgran[idxnummaspeq]){
                    numgran[idxnummaspeq] = vector[idx];
                }
                NumMasGrandes2(vector, numgran, idx+1);
            }
        }
    }

        int vector[] = {2, 1, 3, 9, 5, 6, 4, 8, 7};
        int numgran2[] = new int[4];
        NumMasGrandes2(vector, numgran2, 0);
        System.out.print("M2: Los mayores valores son "+numgran2[0]);
        for (int i=1;i+1<numgran2.length;i++)
            System.out.print(", "+numgran2[i]);
        System.out.print(" y "+numgran2[numgran2.length-1]);

[Gaudy]

Iniciado por HackmanC

Ya lo hice, es decir, el código que puse hace exactamente lo mismo pero seguramente mucho mas eficientemente, sin usar recursión, ni copias de vectores, usa 1,000 integers para buscar en 1,000 integers, como debe ser.

De hecho tu ejemplo posiblemente si es útil, ¿sabías que para buscar el mayor de 100 integers, tu algoritmo almacena 5050 integers, y para buscar en 1000 almacena 500500 integers? Sí, son dos megas nada más, pero el factor de almacenamiento aumentó en 2,002,000%.

Sabías que no te alcanzaría la memoria RAM de tu computadora para buscar el mayor en 100,000 números, para lo cual necesitarías aproximadamente 20 gigabytes. Eso solo es el consumo de memoria.

Bueno, seguramente algún motivo habrá que yo no puedo entender.

Saludos,

Buenas, soy nuevo en el foro y tambien recien iniciado en Programacion en Java, pero leyendo este hilo me llamo la atencion tu comentario

¿Qué calculos realizaste para saber la cantidad de integers almacenados con tal de ejecutar el algoritmo completo?

Con tal de saber q algoritmos son mas eficientes o no.

[HackmanC]

Hola,

Iniciado por Gaudy

... ¿Qué calculos realizaste para saber la cantidad de integers almacenados con tal de ejecutar el algoritmo completo? ...

Estaban incorrectos de cualquier forma, el método es estático, así que las variables son estáticas automáticamente. El consumo de memoria no es tan alto, pero aún así, un algoritmo sequencial es mucho mas eficiente en este caso desde cualquier punto de vista.

Si el método no hubiera sido estático, entonces el consumo de memoria hubiera sido el cálculo que realice, realmente lo hice rápida y empíricamente, igual un método no estático no lo hubiera podido llamar desde el psvm. A veces contesto demasiado rápido y no pongo completa atención a todos los detalles, pero algo es seguro ... no uses recursión donde no se necesita.

Un detalle importante es que cualquier algoritmo que use recursión se puede resolver con un algoritmo secuencial. Pero los algoritmos recursivos existen para facilitarnos la programación en algunos casos no para hacerla mas compleja.

Saludos,