duda método de ordenacion burbuja en Java

[virgi1911]

No entiendo porque en el for ,a n hay que restar uno.Alguien me lo explica?

Código: [Seleccionar]

int sw = 0;
do {
k = k + 1;
sw = 0;
for (i = n - 1; i >= k; i--) {
if (lista[i].compareTo(lista[i - 1]) < 0) { // >0 1ª Cad.es
// mayor|<0 2ª
// Cad.es mayor
String cadaux = lista[i];
lista[i] = lista[i - 1];
lista[i - 1] = cadaux;
sw = 1;
}
}
} while (sw == 1 && k < n - 1);

[DrKlauss]

Hola virgi, esto está relacionado con los índices de los arrays. Si tú defines un array como int[] miArray = new int[4], los elementos del array son miArray[0], miArray[1], miArray[2], y miArray[3]. Entonces si llamas a n al número de elementos del array, para hacer un recorrido desde el final al principio tienes que empezar desde n-1 que es 3 porque el elemento miArray[4] no existe. Es un poco lioso pero así es como funcionan los índices de arrays en muchos lenguajes. Mira este código java que a lo mejor te resulta más claro:

import java.util.Arrays;

public class TestBurbuja {

    public static void main (String[] args) {
        int[] serie1 = {22, 3, 55, -3, 7, -2};
        AlgoritmoBurbuja algo1 = new AlgoritmoBurbuja();
        System.out.println ("Entrada: "+ Arrays.toString(serie1));
        System.out.println ("Resultado: "+ Arrays.toString(algo1.OrdenarPorBurbuja(serie1)));
    }
}

import java.util.Arrays;

public class AlgoritmoBurbuja {

    public AlgoritmoBurbuja() {}

    public int[] OrdenarPorBurbuja(int[] vector) {       // Ordenación de menor a mayor

        int temp = 0;

       
        //Los elementos del vector van de 0 a vector.length menos 1. Partimos de 1 para poder comparar con el cero
        for (int i = 1; i < vector.length; i++) {   

            for (int j = vector.length - 1; j >=i ; j--) {  //Comparamos todos los elementos superiores (todavía no ordenados)
             
                if (vector[j] < vector[j-1]) { //Si es menor que el anterior lo guardamos en temp
                    temp = vector[j];
                    vector[j] = vector[j -1]; //Intercambiamos el mayor y lo ponemos en la posición superior
                    vector[j-1] = temp;  //Ponemos el menor en la posición correcta
                }
            }
            System.out.println ("Situación del vector: " + Arrays.toString(vector));
            //Si había un elemento superior en posiciones altas habrá ido bajando hasta la posición analizada y habrá quedado ordenado un elemento
        }
        return vector;
    }

}

El resultado de ejecución es este:

Entrada: [22, 3, 55, -3, 7, -2]
Situación del vector: [-3, 22, 3, 55, -2, 7]
Situación del vector: [-3, -2, 22, 3, 55, 7]
Situación del vector: [-3, -2, 3, 22, 7, 55]
Situación del vector: [-3, -2, 3, 7, 22, 55]
Situación del vector: [-3, -2, 3, 7, 22, 55]
Resultado: [-3, -2, 3, 7, 22, 55]

Si te fijas en cada paso del proceso se fija un elemento. Se empieza por el final del array y se empieza a bajar el elemento si es menor que el anterior. En el primer paso con i=1 queda colocado el elemento menor de todos en el índice 0. En el segundo paso con i=2 queda colocado el siguiente menor en el índice 1. Y así hasta que queda ordenado.