Sorteo rápido en Java explicado

Quick Sort, también escrito como Quicksort, es un esquema de clasificación de listas que utiliza el paradigma dividido y conquistador. Existen diferentes esquemas para un tipo rápido, todos utilizando el paradigma de división y conquista. Antes de explicar el orden rápido, el lector debe conocer la convención para reducir a la mitad una lista o subsist y la mediana de tres valores.

Convención de la mitad

Cuando el número de elementos en una lista es par, reducir a la mitad la lista significa que la primera mitad literal de la lista es la primera mitad, y la segunda mitad literal de la lista es la segunda mitad. El elemento medio (medio) de la lista completa es el último elemento de la primera lista. Esto significa que el índice medio es longitud / 2 - 1, ya que el recuento de índice comienza desde cero. La longitud es el número de elementos en la lista. Por ejemplo, si el número de elementos es 8, entonces la primera mitad de la lista tiene 4 elementos y la segunda mitad de la lista también tiene 4 elementos. Eso está bien. Dado que el recuento de índice comienza a partir de 0, el índice medio es 3 = 8/2 - 1.

¿Qué pasa con el caso, cuando el número de elementos en la lista o la subsist es impar?? Al principio, la longitud todavía está dividida por 2. Por convención, el número de elementos en la primera mitad de esta división es la longitud / 2 + 1/2. El conteo de índice comienza desde cero. El índice medio se da por longitud / 2 - 1/2. Esto se considera como el término medio, por convención. Por ejemplo, si el número de elementos en una lista es 5, entonces el índice medio es 2 = 5/2 - 1/2. Y, hay tres elementos en la primera mitad de la lista y dos elementos en la segunda mitad. El elemento medio de la lista completa es el tercer elemento en el índice, 2, que es el índice medio porque el recuento de índice comienza a partir de 0.

La división de esta manera es un ejemplo de aritmética entera.

Mediana de tres valores

Pregunta: ¿Cuál es la mediana de la secuencia:

C B A

Solución:
Organice la lista en orden ascendente:

A B C

El término medio, b, es la mediana. Es la magnitud que se encuentra entre las otras dos magnitudes.

Buscar la mediana en una lista no es ese tipo. Por ejemplo, en una lista de 19 elementos sin clasificar, la mediana para el primer elemento, el elemento medio y el último elemento pueden ser necesarios. Estos tres valores pueden no estar en orden ascendente; Y así, sus índices deben tenerse en cuenta.

Con un orden rápido, se requiere la mediana de toda la lista y las subsists. El pseudocódigo para buscar la mediana de tres valores espaciados en una lista (matriz) es:

Mid: = ⌊ (bajo + alto) / 2⌋
Si arr [medio] < arr[low]
Swap ARR [bajo] con ARR [Mid]
Si arr [alto] < arr[low]
intercambio arr [bajo] con arr [alto]
Si arr [medio] < arr[high]
intercambio arr [medio] con arr [alto]
pivote: = arr [alto]

El término "arr" significa matriz. Este segmento de código busca la mediana y también hace alguna clasificación. Este segmento de código parece simple, pero puede ser bastante confuso. Entonces, preste atención a la siguiente explicación:

La clasificación en este tutorial producirá una lista donde el primer valor es el valor más pequeño, y el último valor es el mayor valor. Con el alfabeto, A es menor que Z.

Aquí, el pivote es la mediana resultante. Low es el índice más bajo de la lista o sublist (no necesariamente para el valor más bajo); High es el índice más alto de la lista o sublist (no necesariamente para el valor más alto), y el medio es el índice medio convencional (no necesariamente para el valor medio de toda la lista).

Entonces, la mediana a obtener es entre el valor del índice más bajo, el valor del índice medio y el valor del índice más alto.

En el código, el índice medio convencional se obtiene primero. En este inicio, la lista no está clasificada. La comparación y algunos reordenamientos en orden ascendente de los tres valores se realizarán al mismo tiempo. El primero en estado de la condición if compara el valor para el índice más bajo y el del índice medio. Si el del índice medio es menor que el del índice más bajo, entonces los dos valores de intercambio de posiciones. Esto comienza a clasificar y cambia la disposición de los valores en la lista o la subsist. El segundo if-statement compara el valor para el índice más alto y el del índice más bajo. Si el del índice más alto es menor que el del índice más bajo, las dos posiciones de intercambio de valores. Esto continúa con alguna clasificación y cambio de la disposición de valores en la lista o sub-list. El tercer estado de Estado compara el valor para el índice medio y el del índice más alto. Si el del índice más alto es menor que el índice medio, los dos valores de intercambio de posiciones. También puede ocurrir alguna clasificación o reorganización aquí. Esta tercera condición if no es como las dos anteriores.

Al final de estos tres swaps, el valor medio de los tres valores en cuestión sería un [alto], cuyo contenido original podría haberse cambiado en el segmento de código. Por ejemplo, considere la secuencia no organizada:

C B A

Ya sabemos que la mediana es B. Sin embargo, esto debería probarse. El objetivo aquí es obtener la mediana de estos tres valores utilizando el segmento de código anterior. La primera declaración de IF se compara B y C. Si B es menor que C, entonces las posiciones de B y C deben cambiarse. B es menor que C, por lo que el nuevo arreglo se convierte en:

B C A

Aviso, los valores para el índice más bajo y el índice medio han cambiado. El segundo if-statement compara A y B. Si A es menor que B, entonces las posiciones de A y B deben cambiarse. A es menor que B, por lo que el nuevo arreglo se convierte en:

A C B

Aviso, los valores para el índice más alto y el índice más bajo han cambiado. El tercer if-statement compara C y B. Si C es menor que B, entonces las posiciones de C y B deben cambiarse. C no es inferior a B, por lo que no se realiza el intercambio. El nuevo arreglo permanece como el anterior, es decir:

A C B

B es la mediana, que es, un [alto], y es el eje. Entonces, el pivote nace en el extremo de la lista o la subsist.

La función de intercambio

Otra característica que se necesita para el tipo rápido es la función de intercambio. La función de intercambio, intercambia los valores de dos variables. El pseudocódigo para la función de intercambio es:

Definir intercambio (x, y)
temperatura: = x
x: = y
y: = temperatura

Aquí, x e y se refieren a los valores reales y no a las copias.

La clasificación en este artículo producirá una lista donde el primer valor es el valor más pequeño, y el último valor es el mayor valor.

Contenido del artículo

• Algoritmo de clasificación rápida
• Un pseudocódigo de partición
• Ilustración de clasificación rápida
• Codificación de Java
• Conclusión

Algoritmo de clasificación rápida

La forma normal de ordenar una lista sin clasificar es considerar los dos primeros valores. Si no están en orden, póngalos en orden. A continuación, considere los primeros tres valores. Escanee los dos primeros para ver dónde se ajusta el tercer valor y se ajusta adecuadamente. Luego, considere los primeros cuatro valores. Escanee los primeros tres valores para ver dónde se ajusta el cuarto valor y se ajusta adecuadamente. Continúe con este procedimiento hasta que se ordene toda la lista.

Este procedimiento, también conocido como el tipo de fuerza bruta, en el lenguaje de programación de computadoras, es demasiado lento. El algoritmo de clasificación rápida viene con un procedimiento mucho más rápido.

Los pasos para el algoritmo QuickSort son los siguientes:

1. Asegúrese de que haya al menos 2 números para ordenar en la lista sin clasificar.
2. Obtener un valor central estimado para la lista, llamado pivote. La mediana, como se describió anteriormente, es una forma de obtener el pivote. Diferentes formas vienen con sus ventajas y desventajas. - Nos vemos.
3. Partir la lista. Esto significa, coloque el pivote en la lista. De tal manera, todos los elementos de la izquierda son menores que el valor de pivote, y todos los elementos de la derecha son mayores o iguales al valor de los pivote. Hay diferentes formas de partición. Cada método de partición viene con sus ventajas y desventajas. La partición se divide en el paradigma de división y conquista.
4. Repita los pasos 1, 2 y 3 de manera recursiva para los nuevos pares de subproductos que emergen hasta que se ordene toda la lista. Esto está conquistando en el paradigma de división y conquista.

El pseudocódigo de clasificación rápida es:

Algoritmo Quicksort (arr, bajo, alto) es
Yo fluyo < high then
Pivote (bajo, alto)
p: = partición (arr, bajo, alto)
Quicksort (arr, bajo, p - 1)
Quicksort (arr, p + 1, alto)

Un pseudocódigo de partición

El pseudocodo de partición utilizado en este tutorial es:

La partición de algoritmo (arr, baja, alta) es
pivote: = arr [alto]
i: = bajo
J: = alto
hacer
hacer
++i
mientras (arr [i] < pivot)
hacer
--j
Mientras (arr [j]> pivote)
si yo < j)
intercambio arr [i] con arr [j]
mientras yo < j)
intercambio arr [i] con arr [alto]
regreso

En la ilustración de la clasificación rápida a continuación, se utiliza este código:

Ilustración de clasificación rápida

Considere la siguiente lista no organizada (matriz) de letras alfabéticas:

P W E R T Y U I O P

Por inspección, la lista ordenada es:

E i o p q r t u w y

La lista ordenada ahora estará probada, utilizando el algoritmo anterior y los segmentos de pseudocodos, de la lista no organizada:

P W E R T Y U I O P

El primer pivote se determina a partir de arr [0] = q, arr [4] = t, y arr [9] = p, y se identifica como q y se coloca en la extrema derecha de la lista. Entonces, la lista con cualquier clasificación de función dinámica se convierte en:

P w e r t y u i o q

El pivote actual es Q. El procedimiento de pivote hizo una pequeña clasificación y colocó P en la primera posición. La lista resultante debe reorganizarse (dividirse), de modo que todos los elementos de la izquierda tienen un valor más pequeño, entonces el pivote y todos los elementos a la derecha del pivote, son iguales o mayores que el pivote. La computadora no puede hacer particiones por inspección. Entonces, lo hace usando los índices y el algoritmo de partición anterior.

Los índices bajos y altos ahora son 0 y 9. Por lo tanto, la computadora comenzará escaneando desde el índice 0 hasta que alcance un índice, cuyo valor es igual o mayor que el pivote y se detiene allí temporalmente. También escaneará desde el extremo alto (derecha), índice 9, bajando, hasta que alcanza un índice cuyo valor es menor o igual al pivote y se detiene temporalmente. Esto significa dos posiciones de parada. Si yo, la variable del índice incremental, de baja, aún no es igual o mayor que la variable del índice decreciente, j de alto, entonces estos dos valores se intercambian. En la situación actual, el escaneo desde ambos extremos se detuvo en W y O. Entonces la lista se convierte en:

P o e r t y u i w q

El pivote sigue siendo Q. El escaneo en direcciones opuestas continúa y se detiene en consecuencia. Si aún no es igual o mayor que j, entonces los dos valores en los que se detienen el escaneo desde ambos extremos se detienen. Esta vez, escanear desde ambos extremos se detuvo en R y yo. Entonces, la disposición de la lista se convierte en:

P o e i t y u r w Q

El pivote sigue siendo Q. El escaneo en direcciones opuestas continúa y se detiene en consecuencia. Si aún no es igual o mayor que j, entonces los dos valores en los que se detuvo el escaneo. Esta vez, escanear desde ambos extremos se detuvo en T para I y yo para J. Yo y J hemos conocido o cruzado. Entonces, no puede haber intercambio. La lista sigue siendo la misma que:

P o e i t y u r w Q

En este punto, el pivote, Q, debe colocarse en su posición final en la clasificación. Esto se hace intercambiando arr [i] con arr [alto], intercambiando t y q. La lista se convierte en:

P o e i q y u r w t

En este punto, la partición para toda la lista ha terminado. El pivot = q ha jugado su papel. Ahora hay tres subsistras, que son:

P o e i q y u r w t

La partición es división y conquistar (clasificación) en el paradigma. Q está en su posición de clasificación correcta. Cada elemento a la izquierda de Q es más pequeño que Q, y cada elemento a la derecha de Q es más grande que Q. Sin embargo, la lista de la izquierda aún no está ordenada; y la lista correcta todavía no está ordenada. Toda la función de clasificación rápida debe llamarse recursivamente para clasificar la subconjunción izquierda y la subsistencia derecha. Este recuerdo de clasificación rápida tiene que continuar; Se desarrollarán nuevas sub-listas hasta que toda la lista original esté completamente ordenada. Para cada recuerdo de la función de clasificación rápida, la subsistencia izquierda se atiende primero antes de que se atienda la subsistencia derecha correspondiente a. Se debe obtener un nuevo pivote para cada subsist.

Para la sublista:

P o e i

El pivote (mediano) para p, o y yo está determinado. El pivote sería O. Para esta subsist, y en relación con la lista completa, el nuevo ARR [bajo] es ARR [0], y el nuevo ARR [alto] es el último ARR [i-1] = ARR [4-1] = ARR [3], donde yo es el índice de pivote final de la partición anterior. Después de que se haya llamado a la función Pivot (), el nuevo valor de pivote, pivot = o. No confunda entre la función de pivote y el valor de pivote. La función de pivote puede hacer una pequeña clasificación y colocar el pivote en la extrema derecha de la subsist. Esta sublista se convierte en,

I P E O

Con este esquema, el pivote siempre termina en el extremo derecho de la subsist o la lista después de su llamada de función. Escaneo desde ambos extremos comienza desde arr [0] y arr [3] hasta que yo y j se encuentran o cruzan. La comparación se realiza con Pivot = O. Las primeras paradas están en P y E. Se intercambian y la nueva subsist se convierte en:

I E P O

El escaneo desde ambos extremos continúa, y las nuevas paradas están en P para I y en E para J. Ahora yo y J hemos conocido o cruzado. Entonces, la subsists sigue siendo la misma que:

I E P O

La partición de una subsist o lista finaliza cuando el pivote se ha puesto en su posición final. Entonces, los nuevos valores para arr [i] y arr [high] se intercambian. Es decir, P y O están intercambiados. La nueva subsist se convierte en:

I e o p

O ahora está en su posición final para toda la lista. Su papel como un pivote ha terminado. La subsist se divide actualmente en tres listas más, que son:

I e o p

En este punto, se debe llamar a la primera subsist de la primera subsist. Sin embargo, no se llamará. En cambio, se anotará y reservará, para ser llamado más tarde. Como las declaraciones de la función de partición se estaban ejecutando, desde la parte superior de la función, es el tipo rápido para la subsistencia izquierda que debe llamarse ahora (después de que se haya llamado pivot ()). Se le llamará para la lista:

ES DECIR

Comenzará buscando la mediana de i y e. Aquí, arr [bajo] = i, arr [mid] = i y arr [alto] = e. Entonces la mediana, pivote, debe determinarse por el algoritmo de pivote como, yo. Sin embargo, el pseudocódigo pivote anterior determinará el pivote como e. Este error ocurre aquí porque el pseudocódigo anterior está destinado a tres elementos y no dos. En la implementación a continuación, hay algún ajuste al código. La subsist se convierte,

E I

El pivote siempre termina en el extremo derecho de la subsist o la lista después de su llamada de función. Escaneo desde ambos extremos comienza desde arr [0] y arr [1] exclusivo hasta que yo y j se encuentren o cruzan. La comparación se realiza con Pivot = I. Las primeras y únicas paradas están en I y E: en i para i y en e por j. Ahora yo y J hemos conocido o cruzado. Entonces, la subsists sigue siendo la misma que:

E I

La partición de una subsist o lista finaliza cuando el pivote se ha puesto en su posición final. Entonces, los nuevos valores para arr [i] y arr [high] se intercambian. Sucede aquí que arr [i] = i y arr [alto] = i. Entonces, el mismo valor se cambia consigo mismo. La nueva subsist se convierte en:

E I

Ahora estoy en su posición final para toda la lista. Su papel como un pivote ha terminado. La subsist ahora se divide en dos listas más, que son,

E I

Ahora, los pivotes hasta ahora han sido Q, O, y yo. Los pivotes terminan en sus posiciones finales. Una subsist de un solo elemento, como la P anterior, también termina en su posición final.

En este punto, la primera subsist izquierda ha sido completamente ordenada. Y el procedimiento de clasificación ahora está en:

E i o p q y u r w t

La primera subsist de la derecha:

Y u r w t

todavía necesita ser ordenado.

Conquistando la primera subsist de la derecha
Recuerde que la llamada de clasificación rápida para la primera subsist de la derecha se observó y reservó en lugar de ser ejecutada. En este punto, se ejecutará. Y así, el nuevo arr [bajo] = arr [5] = arr [qpivotindex+1], y el nuevo arr [high] permanece ARR [9]. Un conjunto similar de actividades que ocurrieron para la primera subsist de la izquierda sucederá aquí. Y esta primera subsist de la derecha se clasifica para:

R t u w y

Y la lista original sin clasificar se ha ordenado a:

E i o p q r t u w y

Codificación de Java

Poner el algoritmo en Java es solo poner todos los segmentos de pseudocodos anteriores en métodos Java en una clase. No olvide que debe haber un método main () en la clase que llame a la función QuickSort () con la matriz no organizada.

El método pivot ()

El método Java Pivot () que devuelve el valor, Pivot, debe ser:

Void Pivot (char arr [], int low, int high)
int mid = (bajo + alto) / 2;
if (arr [medio] < arr[low])
intercambio (arr, bajo, medio);
if (arr [alto] < arr[low])
intercambio (arr, bajo, alto);
if ((alto - bajo)> 2)
if (arr [medio] < arr[high])
intercambio (arr, mediano, alto);

El método swap ()

El método swap () debe ser:

Swap void (char arr [], int x, int y)
char temp = arr [x];
arr [x] = arr [y];
arr [y] = temp;

El método QuickSort ()

El método QuickSort () debe ser:

Void Quicksort (char Arr [], int low, int high)
Yo fluyo < high)
pivote (arr, bajo, alto);
int p = partición (arr, baja, alta);
Quicksort (arr, bajo, p - 1);
Quicksort (arr, p + 1, alto);

El método de partición ()

El método PARTITION () debe ser:

Int Partition (Char Arr [], int Low, int High)
char pivot = arr [high];
int i = bajo;
int j = alto;
hacer
hacer
++i;
mientras (arr [i] < pivot);
hacer
--J;
while (arr [j]> pivot);
si yo < j)
intercambio (arr, i, j);
mientras yo < j);
intercambio (arr, i, alto);
regresar i;

El método main ()

El método main () puede ser:

public static void main (string [] args)
char arr [] = 'q', 'w', 'e', ​​'r', 't', 'y', 'u', 'i', 'o', 'p';
THECLASS QuickSort = new THECLASS ();
Ordenación rápida.Quicksort (arr, 0, 9);
Sistema.afuera.println ("Los elementos ordenados:");
para (int i = 0; i<10; i++)
Sistema.afuera.imprimir (arr [i]); Sistema.afuera.imprimir(");

Sistema.afuera.println ();

Todos los métodos anteriores se pueden poner en una clase.

Conclusión

Quick Sort es un algoritmo de clasificación que utiliza el paradigma dividido y conquistador. Comienza dividiendo una lista sin clasificar en dos o tres sub-listas. En este tutorial, Quick Sort ha dividido una lista en tres subsists: una subsist izquierda, una lista intermedia de un solo elemento y una subsists derecha. Conquistar en un tipo rápido es dividir una lista o una subsist mientras la clasifica, utilizando un valor de pivote. Este tutorial ha explicado una implementación de un tipo rápido en el lenguaje informático de Java.