Scribd
Cargar
178 vistas

Java Quicksort

El documento describe el algoritmo de ordenación Quicksort desarrollado por Hoare en 1960. Explica que divide recursivamente el array en subarrays más pequeños usando un pivote, y ordena los elementos menores y mayores de forma dividida. También presenta el pseudocódigo del método quicksort en Java para ordenar un array de enteros de forma recursiva.

Cargado por

gilmarsucre
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
178 vistas

Java Quicksort

El documento describe el algoritmo de ordenación Quicksort desarrollado por Hoare en 1960. Explica que divide recursivamente el array en subarrays más pequeños usando un pivote, y ordena los elementos menores y mayores de forma dividida. También presenta el pseudocódigo del método quicksort en Java para ordenar un array de enteros de forma recursiva.

Cargado por

gilmarsucre
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 4

Java Quicksort

http://puntocomnoesunlenguaje.blogspot.com/2012/12/java-quicksort.html

El método de ordenación Quicksort fue desarrollado por Hoare en el año 1960.


Es el algoritmo de ordenación más rápido.

Se basa en la técnica divide y vencerás, que consiste en ir subdividiendo el array en arrays más
pequeños, y ordenar éstos. Para hacer esta división, se toma un valor del array como pivote, y se
mueven todos los elementos menores que este pivote a su izquierda, y los mayores a su derecha. A
continuación se aplica el mismo método a cada una de las dos partes en las que queda dividido el array.

Después de elegir el pivote se realizan dos búsquedas:

Una de izquierda a derecha, buscando un elemento mayor que el pivote


Otra de derecha a izquierda, buscando un elemento menor que el pivote.

Cuando se han encontrado los dos elementos anteriores, se intercambian, y se sigue realizando la
búsqueda hasta que las dos búsquedas se encuentran.

La implementación del método de ordenación Quicksort es claramente recursiva.

Suponiendo que tomamos como pivote el primer elemento, el método Java Quicksort que implementa
este algoritmo de ordenación para ordenar un array de enteros se presenta a continuación. Los
parámetros izq y der son el primer y último elemento del array a tratar en cada momento.

El método ordena un array A de enteros desde la posición izq hasta la posición der. En la primera llamada
recibirá los valores izq = 0, der = ELEMENTOS-1.

public static void quicksort(int A[], int izq, int der) {

int pivote=A[izq]; // tomamos primer elemento como pivote


int i=izq; // i realiza la búsqueda de izquierda a derecha
int j=der; // j realiza la búsqueda de derecha a izquierda
int aux;

while(i<j){ // mientras no se crucen las búsquedas


while(A[i]<=pivote && i<j) i++; // busca elemento mayor que pivote
while(A[j]>pivote) j--; // busca elemento menor que pivote
if (i<j) { // si no se han cruzado
aux= A[i]; // los intercambia
A[i]=A[j];
A[j]=aux;
}
}
A[izq]=A[j]; // se coloca el pivote en su lugar de forma que tendremos
A[j]=pivote; // los menores a su izquierda y los mayores a su derecha
if(izq<j-1)
quicksort(A,izq,j-1); // ordenamos subarray izquierdo
if(j+1 <der)
quicksort(A,j+1,der); // ordenamos subarray derecho
}
De forma gráfica el proceso sería el siguiente:

La elección del pivote determinará la eficiencia de este algoritmo ya que determina la partición del array.
Si consideramos que el array está desordenado, podemos elegir el primer elemento y el algoritmo
funcionaría de forma eficiente. Pero si el array está casi ordenado, elegir el primer elemento como pivote
sería una mala solución ya que obtendríamos un subarray muy pequeño y otro muy grande. Por la misma
razón, elegir el último elemento del array como pivote también es una mala idea. Pretendemos conseguir
que el tamaño de los subarrays sea lo más parecido posible.

Una alternativa a elegir el primer elemento es elegir como pivote un elemento al azar de entre todos los
del array.

Otra estrategia es calcular la mediana de los valores de la izquierda, centro y derecha del vector.
Por ejemplo para el vector: 9 8 1 6 10 2 3, se calcula la mediana de los elementos que ocupan el primer
lugar, el último y el centro o sea 9 3 6. La mediana es 6 que determinaría las particiones {1 3 2} {6} {8 10
9}.

En el peor caso, cuando el pivote es el elemento menor del array el tiempo de ejecución del
método Quicksort es O(n2).
En general el tiempo medio de ejecución del Quicksort es O(n log n).

Como imprimir el arreglo ordenado?

for(int i = 0;i<array.length;i++)
System.out.println(array[i));

Algoritmo Mergesort.

public static int[] mergeSort(int a[]) {


return divide(a, a.length);
}

public static int[] divide(int a[], int n) {


if (n > 1) {
if (n % 2 == 0) {
int a1[] = new int[n / 2];
int a2[] = new int[n / 2];
for (int i = 0; i < n; i++) {
if (i < n / 2) {
a1[i] = a[i];
} else {
int ind = i - (n / 2);
a2[ind] = a[i];
}
}
return combina(divide(a1, n / 2), divide(a2, n / 2), n);
} else {
int a1[] = new int[(n - 1) / 2];
int a2[] = new int[(n + 1) / 2];
for (int j = 0; j < n; j++) {
if (j < (n - 1) / 2) {
a1[j] = a[j];
} else {
int ind = j - ((n - 1) / 2);
a2[ind] = a[j];
}
}
return combina(divide(a1, (n - 1) / 2), divide(a2, (n + 1) / 2), n);
}
} else {
return a;
}
}

public static int[] combina(int a1[], int a2[], int n) {


int i = 0, j = 0, k = 0;
int z[] = new int[n];

if (n % 2 == 0) {
while (k < n) {
if (i >= (n / 2)) {
z[k] = a2[j];
j++;
} else if (j >= (n / 2)) {
z[k] = a1[i];
i++;
} else if (a1[i] <= a2[j]) {
z[k] = a1[i];
i++;
} else {
z[k] = a2[j];
j++;
}
k++;
}
return z;
} else {
while (k < n) {
if (i >= ((n - 1) / 2)) {
z[k] = a2[j];
j++;
} else if (j >= ((n + 1) / 2)) {
z[k] = a1[i];
i++;
} else if (a1[i] <= a2[j]) {
z[k] = a1[i];
i++;
} else {
z[k] = a2[j];
j++;
}
k++;
}
return z;
}
}

También podría gustarte