Como usar a classificação de bitmap Java

Copie o código do código da seguinte forma:

/**
* Executa uma classificação na seção do array entre os índices fornecidos
* usando um mergesort com algoritmo de busca exponencial (no qual a mesclagem
* é realizado por pesquisa exponencial). O desempenho n*log(n) é garantido.
* e no caso médio será mais rápido que qualquer mergesort no qual o
* a mesclagem é realizada por pesquisa linear.
*
* @param em -
* o array para classificação.
* @param fora -
* o resultado, array ordenado.
* @param início
* o índice inicial
* @param fim
* o índice final + 1
*/
@SuppressWarnings("desmarcado")
private static void mergeSort(Object[] in, Object[] out, int start,
pretende) {
int len ​​= fim - início;
// usa ordenação por inserção para arrays pequenos
if (len <= SIMPLE_LENGTH) {
for (int i = início + 1; i < fim; i++) {
Comparable<Object> current = (Comparable<Object>) out[i];
Objeto anterior = saída[i - 1];
if (atual.compareTo(anterior) < 0) {
int j = eu;
fazer {
saída[j--] = anterior;
} while (j > iniciar
&& current.compareTo(prev = out[j - 1]) < 0);
saída[j] = atual;
}
}
retornar;
}
int med = (fim + início) >>> 1;
mergeSort(sai, entra, inicia, med);
mergeSort(saída, entrada, meio, fim);

// mesclando

// se os arrays já estiverem ordenados - sem mesclagem
if (((Comparable<Object>) in[med - 1]).compareTo(in[med]) <= 0) {
System.arraycopy(entrada, início, saída, início, len);
retornar;
}
int r = med, i = início;

// usa mesclagem com pesquisa exponencial
fazer {
Comparable<Object> fromVal = (Comparable<Object>) in[start];
Comparable<Object> rVal = (Comparable<Object>) in[r];
if (fromVal.compareTo(rVal) <= 0) {
int l_1 = encontrar(in, rVal, -1, início + 1, med - 1);
int toCopy = l_1 - início + 1;
System.arraycopy(in, start, out, i, toCopy);
i += paraCopiar;
saída[i++] = rVal;
r++;
início = l_1 + 1;
} outro {
int r_1 = encontrar(in, fromVal, 0, r + 1, fim - 1);
int paraCopiar = r_1 - r + 1;
System.arraycopy(in, r, out, i, toCopy);
i += paraCopiar;
fora[i++] = deVal;
iniciar++;
r = r_1 + 1;
}
} while ((end - r) > 0 && (med - start) > 0);

//copia o resto do array
if ((fim - r) <= 0) {
System.arraycopy(in, start, out, i, med - start);
} outro {
System.arraycopy(in, r, out, i, end - r);
}
}

Copie o código do código da seguinte forma:

classe pública javaUniqueSort {
public static int[] temp = new int[1000001];
public static List<Integer> tempList = new ArrayList<Integer>();
contagem interna estática pública;

public static void main(final String[] args) {
List<Integer> primeiroNum = new ArrayList<Integer>();
List<Integer> segundoNum = new ArrayList<Integer>();

for (int i = 1; i <= 1000000; i++) {
primeiroNum.add(i);
segundoNum.add(i);
}

Coleções.shuffle(primeiroNum);
Coleções.shuffle(segundoNum);

getStartTime();
Coleções.sort(primeiroNum);
getEndTime("tempo de execução de classificação java");

getStartTime();
segundoNum = uniqueSort(segundoNum);
getEndTime("tempo de execução do UniqueSort");

}

public static List<Integer> uniqueSort(final List<Integer> uniqueList) {
javaUniqueSort.tempList.clear();
for (int i = 0; i < javaUniqueSort.temp.length; i++) {
javaUniqueSort.temp[i] = 0;
}
for (int i = 0; i < uniqueList.size(); i++) {
javaUniqueSort.temp[uniqueList.get(i)] = 1;
}
for (int i = 0; i < javaUniqueSort.temp.length; i++) {
if (javaUniqueSort.temp[i] == 1) {
javaUniqueSort.tempList.add(i);
}
}

retornar javaUniqueSort.tempList;
}

public static void getStartTime() {
javaShuffle.start = System.nanoTime();
}

public static void getEndTime(string final s) {
javaShuffle.end = System.nanoTime();
System.out.println(s + ": " + (javaShuffle.end - javaShuffle.start) + "ns");
}
}

Tempo de execução:

tempo de execução da classificação java: 1257737334ns
tempo de execução de classificação única: 170228290ns
tempo de execução da classificação java: 1202749828ns
Tempo de execução de classificação única: 169327770ns

Copie o código do código da seguinte forma:

classe pública javaDuplicateSort {
public static List<Integer> tempList = new ArrayList<Integer>();
contagem interna estática pública;

public static void main(final String[] args) {
Aleatório aleatório = new Aleatório();
List<Integer> primeiroNum = new ArrayList<Integer>();
List<Integer> segundoNum = new ArrayList<Integer>();

for (int i = 1; i <= 100000; i++) {
primeiroNum.add(i);
segundoNum.add(i);
primeiroNum.add(random.nextInt(i + 1));
segundoNum.add(random.nextInt(i + 1));
}
Coleções.shuffle(primeiroNum);
Coleções.shuffle(segundoNum);

getStartTime();
Coleções.sort(primeiroNum);
getEndTime("tempo de execução de classificação java");

getStartTime();
segundoNum = uniqueSort(segundoNum);
getEndTime("tempo de execução do UniqueSort");

}

public static List<Integer> uniqueSort(final List<Integer> uniqueList) {
javaDuplicateSort.tempList.clear();
int[] temp = new int[200002];
for (int i = 0; i < temp.comprimento; i++) {
temperatura[i] = 0;
}
for (int i = 0; i < uniqueList.size(); i++) {
temp[ListaExclusiva.get(i)]++;
}
for (int i = 0; i < temp.comprimento; i++) {
for (int j = temp[i]; j > 0; j--) {
javaDuplicateSort.tempList.add(i);
}
}

retornar javaDuplicateSort.tempList;
}

public static void getStartTime() {
javaShuffle.start = System.nanoTime();
}

public static void getEndTime(string final s) {
javaShuffle.end = System.nanoTime();
System.out.println(s + ": " + (javaShuffle.end - javaShuffle.start) + "ns");
}
}