[Ajuda] RadixSort

Programação Java
#1

Olá,

acho que é o primeiro post que faço, ja tenho registo a um tempinho mais sempre pra pesquisa
mais estou a muito tempo pesquisando sobre radix sort
e nao acho nada que me ajude.

sei o funcionamento no mesmo na teoria
mais nao consigo achar o codigo fonte.

alguem pode me ajudar?

#2

Se o problema for sintaxe, podemos ajudar sim.
Eu não me recordo do radix sort, mas se você puder colocar o algoritmo aqui eu tento ajuda-lo.
Abraços

#3

[quote=henriqueluz]Se o problema for sintaxe, podemos ajudar sim.
Eu não me recordo do radix sort, mas se você puder colocar o algoritmo aqui eu tento ajuda-lo.
Abraços[/quote]

o Problema que eu tenho a terioria,
so que eu preciso do fonte pra rodar ele sabe
nem o algoritmo nao tenho.

gostaria que se alguem tive-se o fonte disponibilizase pra mim!

#4

[google]radixsort java[/google]
Clique em “Estou com Sorte”

#5

Vou tentar usar esse,

eu testei sabe

so que para ordenar array de 50 numeros ele é lento =/
mais que os outro aqui testei

vou ver aqui

Obrigado

#6

Bom o codigo esta para arrays de int, alguem poderia me ajudar para fazer ordenar array de string?
aqui ela meche com bit e eu nao sei mecher com isso ainda =/
tenho que colocar todos meus algoritmos pra ordenar string será que é possivel?

public class RadixSort {

	public static void radixSort(int[] arr) {
		if (arr.length == 0)
			return;

		int[][] np = new int[arr.length][2];
		int[] q = new int[0x100];
		int i, j, k, l, f = 0;

		for (k = 0; k < 4; k++) {
			for (i = 0; i < (np.length - 1); i++)
				np[i][1] = i + 1;
			np[i][1] = -1;

			for (i = 0; i < q.length; i++)
				q[i] = -1;
			for (f = i = 0; i < arr.length; i++) {
				j = ((0xFF << (k << 3)) & arr[i]) >> (k << 3);
				if (q[j] == -1)
					l = q[j] = f;

				else {
					l = q[j];
					while (np[l][1] != -1)
						l = np[l][1];
					np[l][1] = f;
					l = np[l][1];
				}

				f = np[f][1];
				np[l][0] = arr[i];
				np[l][1] = -1;
			}
			for (l = q[i = j = 0]; i < 0x100; i++)
				for (l = q[i]; l != -1; l = np[l][1])
					arr[j++] = np[l][0];
		}
	}

}

Merge Sort

public class MergeSort {

	private int[] vetor;

	public MergeSort(int[] veto){
		this.vetor = veto;
	}

	public void merge(int inicio, int fim) {
	        if (inicio < fim) {
	                int meio = (inicio + fim) / 2;
	                merge(inicio, meio);
	                merge(meio + 1, fim);
	                mesclar(inicio, meio, fim);
	        }
	}

	private void mesclar(int inicio, int meio, int fim) {
	        int tamanho = fim - inicio + 1;
	        int[] temp = new int[tamanho];
	        System.arraycopy(vetor, inicio, temp, 0, tamanho);

	        int i = 0;
	        int j = meio - inicio + 1;

	        for (int posicao = 0; posicao < tamanho; posicao++) {
	                if (j <= tamanho - 1) {
	                        if (i <= meio - inicio) {
	                                if (temp[i] < temp[j]) {
	                                        vetor[inicio + posicao] = temp[i++];
	                                } else {
	                                        vetor[inicio + posicao] = temp[j++];
	                                }
	                        } else {
	                                vetor[inicio + posicao] = temp[j++];
	                        }
	                } else {
	                        vetor[inicio + posicao] = temp[i++];
	                }
	        }
	}
}

Comb Sort

public class CombSort {

	private static void troca(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

	private static int novoIntervalo(int intervalo) {
		intervalo =(int) (intervalo / 1.3);	
		if (intervalo < 1)
			intervalo = 1;
		return intervalo;
	}

	public static void combsort(int[] a) {
		int intervalo = a.length;
		for (;;) {
			intervalo = novoIntervalo(intervalo);
			boolean trocado = false;
			for (int i = 0; i < a.length - intervalo; i++) {
				if (a[i] > a[i + intervalo]) {
					troca(a, i, i + intervalo);
					trocado = true;
				}
			}
			if (intervalo == 1 && !trocado)
				break;
		}
	}

}

e o bubble Sort

public class Bolha {
	public static int[] ordenar(int[] numeros) {
		int x;
		boolean mudou = true;

		for (int i = 1; i < numeros.length; i++)  {
			for (int j = numeros.length - 1; j >= i; j--)  {
				if (numeros[j-1] > numeros[j]) {
					x = numeros[j-1];
					numeros[j-1] = numeros[j];
					numeros[j] = x;
					mudou = false;
				}
			}
			if (mudou == true)
				i = numeros.length+1;
			mudou = true;

		}
		return numeros;
	}
}
#7