Estou tentando usar o método Quick sort mais não estou conseguindo alguém pode me da uma dica de como eu faço para passar parâmentros pro método,
que o método recebe e o seguinte
private static void ordena(int a[], int p, int u)
o primeiro e o vetor e esse p e u o que é isso???
vo deixar o código aqui embaixo quem souber por favor implemente ou me da uma dica de como passar esses parâmetros
import javax.swing.JOptionPane;
public class Quick
{
/*----------------------------------------------------------------------*/
/* Ordena uma rray pelo método QuickSort (recursivo). */
/* Escolhe o pivô da partição aleatoriamente para minimizar proba- */
/* bilidade de tamanhos muito diferentes das duas metades do ARRAY. */
/* Rearranja o array de tal modo que: */
/* Elementos da primeira metade sejam menores que o pivô */
/* Elementos da segunda metade sejam maiores que o pivô */
/* Parâmetros: array, índices do início e fim do subarray. */
/*----------------------------------------------------------------------*/
private static void ordena(int a[], int p, int u)
{
int i = p, f = u; // Extremos
int x = (int) (Math.random()*(u-p+1))+p; // Aleatório
int pivô = a[x]; // para evitar quadrático
while (i <= f)
{ // Enquanto não se cruzarem
while (i < u && a[i] < pivô) i++; // Organiza primeira metade
while (f > p && a[f] > pivô) f--; // Organiza segunda metade
if (i <= f) { // Se ainda não acabou
x = a[f]; // troca os elementos
a[f--] = a[i]; // dos dois lados
a[i++] = x; // da lista
}
}
if (p < f) ordena(a,p,f); // a[p]..a[f] < pivô
if (i < u) ordena(a,i,u); // a[i]..a[u] > pivô
}
public static void main(String args[])
{
int vet[] = new int [10];
int i;
for(i=0;i<vet.length;i++)
{
vet[i]=Integer.parseInt(JOptionPane.showInputDialog("Dígite o "+(i+1)+"° número"));
ordena(vet);
}
}
/*----------------------------------------------------------------------*/
/* Chamada do usuário (mesma para todos os algoritmos). */
/*----------------------------------------------------------------------*/
}
Olá edymrex,
dá uma olhada nas alterações, espero ter ajudado!
[code]public static void main(String args[])
{
int vet[] = new int [10];
int i;
for(i=0;i<vet.length;i++)
{
vet[i]=Integer.parseInt(JOptionPane.showInputDialog("Dígite o "+(i+1)+"° número"));
}
ordena(vet , 0, vet.length - 1);
String vetor=" ";
for (i=0;i<vet.length;i++)
{
vetor=vetor + vet[i]+" ";
}
JOptionPane.showMessageDialog(null, vetor,"Numeros ordenados ",JOptionPane.PLAIN_MESSAGE);
}[/code]
Valeu cara ajudou bastante, mas não consigo entender como funciona esse algoritimo do Quick Sort a idéia que eu tenho que que ele escolhe um pivô que é sempre o array na posição 0 a partir daí ele vai comparando quando os elementos são <= ao pivô ele fica na esquerda quando são >=pivô eles ficam na direita e isso mesmo que ocorre cara…??
Daí enquanto as duas extremidades não se coincidirem ele vai fazendo um loop e ordenando o array e isso cara…?? eu mudei o código olha como ficou
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
public class Quick
{
/*----------------------------------------------------------------------*/
/* Ordena uma array pelo método QuickSort (recursivo). */
/* Escolhe o pivô da partição aleatoriamente para minimizar proba- */
/* bilidade de tamanhos muito diferentes das duas metades do ARRAY. */
/* Rearranja o array de tal modo que: */
/* Elementos da primeira metade sejam menores que o pivô */
/* Elementos da segunda metade sejam maiores que o pivô */
/* Parâmetros: array, índices do início e fim do subarray. */
/*----------------------------------------------------------------------*/
private static void ordena(int a[], int p, int u)
{
int i = p, f = u; // Extremos
int x = (int) (Math.random()*(u-p+1))+p; // Aleatório
int pivô = a[x]; // para evitar quadrático
while (i <= f) // Enquanto não se cruzarem
{
while (i < u && a[i] < pivô) i++; // Organiza primeira metade
while (f > p && a[f] > pivô) f--; // Organiza segunda metade
if (i <= f) { // Se ainda não acabou
x = a[f]; // troca os elementos
a[f--] = a[i]; // dos dois lados
a[i++] = x; // da lista
}
}
if (p < f) ordena(a,p,f); // a[p]..a[f] < pivô
if (i < u) ordena(a,i,u); // a[i]..a[u] > pivô
}
public static void main(String args[])
{
String saida="";
JTextArea texto = new JTextArea(10,10);
int vet[] = new int [10];
int i;
for(i=0;i<vet.length;i++)
{
vet[i]=Integer.parseInt(JOptionPane.showInputDialog(null,"Dígite o "+(i+1)+"° número","ATENÇÂO",JOptionPane.WARNING_MESSAGE));
}
ordena(vet,0,vet.length-1);
//********************
for (i=0;i<vet.length;i++)
{
saida+=vet[i]+"\n";
}
texto.setText(saida);
JOptionPane.showMessageDialog(null,texto,"ORDENAÇÂO COM QUICK SORT",JOptionPane.WARNING_MESSAGE);
}
/*----------------------------------------------------------------------*/
/* Chamada do usuário (mesma para todos os algoritmos).
* public static void ordena(int a[]) {ordena(a,0,a.length-1);} */
/*----------------------------------------------------------------------*/
}
Se alguém souber por favor me explique em uma linguagem simples e fácil de enteder
p/JLeonardo
Já vi esse algoritimo e diferente do meu…!
queria se possivel saber tudo que o método faz…!
se possivel me ajudar nas questões a qual eu já citei…!
[quote=“edymrex”]p/JLeonardo
Já vi esse algoritimo e diferente do meu…!
queria se possivel saber tudo que o método faz…!
se possivel me ajudar nas questões a qual eu já citei…![/quote]
A ordenação por partição(quicksort) utiliza o processo de partir o vetor ao meio e varrer o vetor das posições extremas para o centro. Do lado esquerdo procura-se o valor menor do que valor central(mediana) e do lado direito o valor maior que a mediana trocando esses valores de posição. Repete-se o processo até que o marcador da esquerda seja maior que o da direita. Ao final deste processo o vetor deve estar dividido em duas partes, do lado esquerdo deverá ter todos os valores menores do que a mediana e do lado direito todos os maiores. Repete-se este processo para cada uma das metades e assim, sucessivamente, até a ordenação do vetor.
Tudo que sei sobre o assunto é isso, se não for suficiente aguarde novos colaboradores. Abraço.