Cómo utilizar la clasificación de mapas de bits de Java

Copie el código de código de la siguiente manera:

/**
* Realiza una clasificación en la sección de la matriz entre los índices dados
* usando un mergesort con algoritmo de búsqueda exponencial (en el que la combinación
* se realiza mediante búsqueda exponencial). El rendimiento n*log(n) está garantizado.
* y en el caso promedio será más rápido que cualquier mergesort en el que el
* la combinación se realiza mediante búsqueda lineal.
*
* @param en -
* la matriz para ordenar.
* @param fuera -
* el resultado, matriz ordenada.
* @param inicio
* el índice de inicio
* @param fin
* el índice final + 1
*/
@SuppressWarnings("sin marcar")
mergeSort de vacío estático privado (Objeto [] adentro, Objeto [] fuera, int inicio,
pretender) {
int len ​​= fin - inicio;
// usa ordenación por inserción para matrices pequeñas
si (len <= SIMPLE_LENGTH) {
para (int i = inicio + 1; i < fin; i++) {
Comparable<Objeto> actual = (Comparable<Objeto>) out[i];
Objeto anterior = salida[i - 1];
si (actual.compareTo(anterior) < 0) {
int j = yo;
hacer {
fuera[j--] = anterior;
} mientras (j > iniciar
&& current.compareTo(prev = out[j - 1]) < 0);
salida[j] = actual;
}
}
devolver;
}
int med = (fin + inicio) >>> 1;
mergeSort(fuera, adentro, inicio, med);
mergeSort(fuera, dentro, med, fin);

// fusionando

// si las matrices ya están ordenadas, no se pueden fusionar
if (((Comparable<Objeto>) en[med - 1]).compareTo(en[med]) <= 0) {
System.arraycopy(entrada, inicio, salida, inicio, len);
devolver;
}
int r = medicina, i = inicio;

// usar fusión con búsqueda exponencial
hacer {
Comparable<Objeto> fromVal = (Comparable<Objeto>) en[inicio];
Comparable<Objeto> rVal = (Comparable<Objeto>) en[r];
si (desdeVal.compareTo(rVal) <= 0) {
int l_1 = buscar(in, rVal, -1, inicio + 1, med - 1);
int toCopy = l_1 - inicio + 1;
System.arraycopy(entrada, inicio, salida, i, toCopy);
i += copiar;
salida[i++] = rVal;
r++;
inicio = l_1 + 1;
} demás {
int r_1 = buscar(en, desdeVal, 0, r + 1, final - 1);
int toCopiar = r_1 - r + 1;
System.arraycopy(entrada, r, salida, i, toCopy);
i += copiar;
fuera[i++] = fromVal;
inicio++;
r = r_1 + 1;
}
} mientras ((fin - r) > 0 && (med - inicio) > 0);

// copia el resto de la matriz
si ((fin - r) <= 0) {
System.arraycopy(entrada, inicio, salida, i, med - inicio);
} demás {
System.arraycopy(entrada, r, salida, i, final - r);
}
}

Copie el código de código de la siguiente manera:

clase pública javaUniqueSort {
int estático público [] temp = nuevo int [1000001];
Lista estática pública<Integer> tempList = new ArrayList<Integer>();
recuento de int estático público;

público estático vacío principal (cadena final [] argumentos) {
Lista<Integer> firstNum = new ArrayList<Integer>();
Lista<Integer> secondNum = new ArrayList<Integer>();

para (int i = 1; i <= 1000000; i++) {
primerNum.add(i);
segundoNum.add(i);
}

Colecciones.shuffle(firstNum);
Colecciones.shuffle(segundoNum);

getHoraInicio();
Colecciones.sort(firstNum);
getEndTime("tiempo de ejecución de clasificación Java ");

getHoraInicio();
segundoNum = UniqueSort(segundoNum);
getEndTime("tiempo de ejecución de clasificación única ");

}

Lista estática pública <Integer> clasificación única (Lista final <Integer> Lista única) {
javaUniqueSort.tempList.clear();
para (int i = 0; i < javaUniqueSort.temp.length; i++) {
javaUniqueSort.temp[i] = 0;
}
para (int i = 0; i < listaúnica.tamaño(); i++) {
javaUniqueSort.temp[uniqueList.get(i)] = 1;
}
para (int i = 0; i < javaUniqueSort.temp.length; i++) {
si (javaUniqueSort.temp[i] == 1) {
javaUniqueSort.tempList.add(i);
}
}

devolver javaUniqueSort.tempList;
}

público estático vacío getStartTime() {
javaShuffle.start = System.nanoTime();
}

getEndTime vacío estático público (cadena final s) {
javaShuffle.end = System.nanoTime();
System.out.println(s + ": " + (javaShuffle.end - javaShuffle.start) + "ns");
}
}

Tiempo de ejecución:

Tiempo de ejecución de clasificación de Java: 1257737334ns
tiempo de ejecución de clasificación única: 170228290ns
Tiempo de ejecución de clasificación de Java: 1202749828ns
tiempo de ejecución de clasificación única: 169327770ns

Copie el código de código de la siguiente manera:

clase pública javaDuplicateSort {
Lista estática pública<Integer> tempList = new ArrayList<Integer>();
recuento de int estático público;

público estático vacío principal (cadena final [] argumentos) {
Aleatorio aleatorio = nuevo Aleatorio();
Lista<Integer> firstNum = new ArrayList<Integer>();
Lista<Integer> secondNum = new ArrayList<Integer>();

para (int i = 1; i <= 100000; i++) {
primerNum.add(i);
segundoNum.add(i);
firstNum.add(random.nextInt(i + 1));
segundoNum.add(random.nextInt(i + 1));
}
Colecciones.shuffle(firstNum);
Colecciones.shuffle(segundoNum);

getHoraInicio();
Colecciones.sort(firstNum);
getEndTime("tiempo de ejecución de clasificación Java ");

getHoraInicio();
segundoNum = UniqueSort(segundoNum);
getEndTime("tiempo de ejecución de clasificación única ");

}

Lista estática pública <Integer> clasificación única (Lista final <Integer> Lista única) {
javaDuplicateSort.tempList.clear();
int[] temp = nuevo int[200002];
for (int i = 0; i < temp.length; i++) {
temperatura[i] = 0;
}
para (int i = 0; i < listaúnica.tamaño(); i++) {
temp[uniqueList.get(i)]++;
}
for (int i = 0; i < temp.length; i++) {
para (int j = temp[i]; j > 0; j--) {
javaDuplicateSort.tempList.add(i);
}
}

devolver javaDuplicateSort.tempList;
}

público estático vacío getStartTime() {
javaShuffle.start = System.nanoTime();
}

getEndTime vacío estático público (cadena final s) {
javaShuffle.end = System.nanoTime();
System.out.println(s + ": " + (javaShuffle.end - javaShuffle.start) + "ns");
}
}