quick sort c with examples
Clasificación rápida en C ++ con ilustración.
Quicksort es un algoritmo de ordenación muy utilizado que selecciona un elemento específico llamado 'pivote' y divide la matriz o lista para clasificarla en dos partes según este pivote s0 que los elementos menores que el pivote están a la izquierda de la lista y los elementos mayores que el pivote están a la derecha de la lista.
Por tanto, la lista se divide en dos sublistas. Es posible que las sublistas no sean necesarias para el mismo tamaño. Entonces Quicksort se llama a sí mismo de forma recursiva para ordenar estas dos sublistas.
=> Consulte la guía de formación perfecta de C ++ aquí.
Lo que vas a aprender:
- Introducción
- Algoritmo general
- Pseudocódigo para Quicksort
- Ilustración
- Ejemplo de C ++
- Ejemplo de Java
- Análisis de complejidad del algoritmo de ordenación rápida
- Clasificación rápida de 3 vías
- Clasificación rápida aleatoria
- Clasificación rápida frente a clasificación combinada
- Conclusión
- Lectura recomendada
Introducción
Quicksort funciona de manera eficiente y más rápida incluso para matrices o listas más grandes.
En este tutorial, exploraremos más sobre el funcionamiento de Quicksort junto con algunos ejemplos de programación del algoritmo de Quicksort.
Como valor de pivote, podemos elegir el primero, el último o el valor medio o cualquier valor aleatorio. La idea general es que, en última instancia, el valor de pivote se coloca en su posición adecuada en la matriz moviendo los otros elementos de la matriz hacia la izquierda o hacia la derecha.
Algoritmo general
El algoritmo general de Quicksort se muestra a continuación.
|_+_|Echemos ahora un vistazo al pseudocódigo para la técnica Quicksort.
Pseudocódigo para Quicksort
|_+_|El funcionamiento del algoritmo de partición se describe a continuación mediante un ejemplo.
En esta ilustración, tomamos el último elemento como pivote. Podemos ver que la matriz se divide sucesivamente alrededor del elemento pivote hasta que tengamos un solo elemento en la matriz.
Ahora presentamos una ilustración de Quicksort a continuación para comprender mejor el concepto.
Ilustración
Veamos una ilustración del algoritmo de ordenación rápida. Considere la siguiente matriz con el último elemento como pivote. Además, el primer elemento se etiqueta bajo y el último elemento es alto.
Preguntas y respuestas de la entrevista de angularjs para pdf experimentado
En la ilustración, podemos ver que movemos los punteros hacia arriba y hacia abajo en ambos extremos de la matriz. Siempre que low apunta al elemento mayor que el pivote y high apunta al elemento menor que el pivote, intercambiamos las posiciones de estos elementos y avanzamos los punteros bajo y alto en sus respectivas direcciones.
Esto se hace hasta que los punteros bajo y alto se crucen. Una vez que se cruzan, el elemento pivote se coloca en su posición adecuada y la matriz se divide en dos. Luego, estas dos submatrices se ordenan de forma independiente utilizando quicksort de forma recursiva.
Ejemplo de C ++
A continuación se muestra la implementación del algoritmo Quicksort en C ++.
|_+_|Producción:
Matriz de entrada
12 23 3 43 51 35 19 45
Matriz ordenada con ordenación rápida
3 12 19 23 35 43 45 51
Aquí tenemos algunas rutinas que se usan para particionar la matriz y llamar a quicksort recursivamente para ordenar la partición, función básica de quicksort y funciones de utilidad para mostrar el contenido de la matriz e intercambiar los dos elementos en consecuencia.
Primero, llamamos a la función de ordenación rápida con la matriz de entrada. Dentro de la función de ordenación rápida, llamamos a la función de partición. En la función de partición, usamos el último elemento como elemento pivote para la matriz. Una vez que se decide el pivote, la matriz se divide en dos partes y luego se llama a la función quicksort para ordenar de forma independiente ambas submatrices.
Cuando la función de ordenación rápida regresa, la matriz se ordena de manera que el elemento pivote esté en su ubicación correcta y los elementos menores que el pivote estén a la izquierda del pivote y los elementos mayores que el pivote estén a la derecha del pivote.
A continuación, implementaremos el algoritmo de ordenación rápida en Java.
Ejemplo de Java
|_+_|Producción:
Matriz de entrada
12 23 3 43 51 35 19 45
Matriz después de ordenar con ordenación rápida
3 12 19 23 35 43 45 51
También en la implementación de Java, hemos usado la misma lógica que usamos en la implementación de C ++. Hemos utilizado el último elemento de la matriz como pivote y se realiza una ordenación rápida en la matriz para colocar el elemento pivote en su posición correcta.
Análisis de complejidad del algoritmo de ordenación rápida
El tiempo que tarda Quicksort en ordenar una matriz depende de la matriz de entrada y la estrategia o método de partición.
Si k es el número de elementos menor que el pivote yn es el número total de elementos, entonces el tiempo general que toma Quicksort se puede expresar de la siguiente manera:
T (n) = T (k) + T (n-k-1) + O (n)
Aquí, T (k) y T (n-k-1) son el tiempo que tardan las llamadas recursivas y O (n) es el tiempo que tardan las llamadas de partición.
preguntas de la entrevista del servidor sql para profesionales experimentados
Analicemos esta complejidad de tiempo para una clasificación rápida en detalle.
# 1) Peor caso : El peor caso en la técnica de ordenación rápida ocurre principalmente cuando seleccionamos el elemento más bajo o más alto de la matriz como pivote. (En la ilustración anterior hemos seleccionado el elemento más alto como pivote). En tal situación, el peor de los casos ocurre cuando la matriz que se va a clasificar ya está clasificada en orden ascendente o descendente.
Por lo tanto, la expresión anterior para el tiempo total tomado cambia como:
T (n) = T (0) + T (n-1) + O (n) que resuelve En2)
# 2) Mejor caso: El mejor caso para la ordenación rápida siempre ocurre cuando el elemento pivote seleccionado es el medio de la matriz.
Por lo tanto, la recurrencia para el mejor de los casos es:
cómo declarar la cola en java
T (n) = 2T (n / 2) + O (n) = O (nlogn)
# 3) Caso promedio: Para analizar el caso promedio de ordenación rápida, debemos considerar todas las permutaciones de matriz y luego calcular el tiempo que toma cada una de estas permutaciones. En pocas palabras, el tiempo medio de clasificación rápida también se convierte en O (nlogn).
A continuación se muestran las diversas complejidades de la técnica de ordenación rápida:
| La complejidad del tiempo del peor de los casos | En 2 ) | |
| estabilidad | No estable, ya que dos elementos con los mismos valores no se colocarán en el mismo orden. | Estable: dos elementos con los mismos valores aparecerán en el mismo orden en la salida ordenada. |
| Mejor complejidad en el tiempo del caso | O (n * log n) | |
| Complejidad de tiempo promedio | O (n * log n) | |
| Complejidad espacial | O (n * log n) |
Podemos implementar la ordenación rápida de muchas formas diferentes simplemente cambiando la elección del elemento pivote (medio, primero o último), sin embargo, el peor de los casos rara vez ocurre para la ordenación rápida.
Clasificación rápida de 3 vías
En la técnica original de ordenación rápida, generalmente seleccionamos un elemento pivote y luego dividimos la matriz en submatrices alrededor de este pivote para que una submatriz consista en elementos menores que el pivote y otra consta de elementos mayores que el pivote.
Pero, ¿qué pasa si seleccionamos un elemento pivote y hay más de un elemento en la matriz que es igual a pivote?
Por ejemplo, considere la siguiente matriz {5,76,23,65,4,4,5,4,1,1,2,2,2,2}. Si realizamos una ordenación rápida simple en esta matriz y seleccionamos 4 como elemento pivote, arreglaremos solo una aparición del elemento 4 y el resto se dividirá junto con los otros elementos.
En cambio, si usamos ordenación rápida de 3 vías, dividiremos la matriz (l… r) en tres submatrices de la siguiente manera:
- Array (l… i) - Aquí, i es el pivote y este array contiene menos elementos que el pivote.
- Array (i + 1… j-1): contiene los elementos que son iguales al pivote.
- Array (j… r): contiene elementos mayores que el pivote.
Por lo tanto, la clasificación rápida de 3 vías se puede usar cuando tenemos más de un elemento redundante en la matriz.
Clasificación rápida aleatoria
La técnica de clasificación rápida se denomina técnica de clasificación rápida aleatoria cuando utilizamos números aleatorios para seleccionar el elemento pivote. En el ordenamiento rápido aleatorio, se llama 'pivote central' y divide la matriz de tal manera que cada lado tiene al menos ¼ de elementos.
El pseudocódigo para la ordenación rápida aleatoria se proporciona a continuación:
|_+_|En el código anterior en 'randomQuickSort', en el paso # 2 seleccionamos el pivote central. En el paso 2, la probabilidad de que el elemento seleccionado sea el pivote central es ½. Por tanto, se espera que el ciclo del paso 2 se ejecute 2 veces. Por lo tanto, la complejidad de tiempo para el paso 2 en ordenación rápida aleatoria es O (n).
Usar un bucle para seleccionar el pivote central no es la forma ideal de implementar la ordenación rápida aleatoria. En su lugar, podemos seleccionar aleatoriamente un elemento y llamarlo pivote central o reorganizar los elementos de la matriz. La complejidad de tiempo esperada en el peor de los casos para el algoritmo de ordenación rápida aleatoria es O (nlogn).
Clasificación rápida frente a clasificación combinada
En esta sección, analizaremos las principales diferencias entre la ordenación rápida y la ordenación combinada.
| Parámetro de comparación | Ordenación rápida | Combinar ordenación |
|---|---|---|
| fraccionamiento | La matriz está dividida alrededor de un elemento pivote y no siempre está necesariamente dividida en dos mitades. Se puede dividir en cualquier proporción. | La matriz se divide en dos mitades (n / 2). |
| Peor complejidad del caso | O (n 2): se requieren muchas comparaciones en el peor de los casos. | O (nlogn) - igual que el caso promedio |
| Uso de conjuntos de datos | No puede funcionar bien con conjuntos de datos más grandes. | Funciona bien con todos los conjuntos de datos independientemente del tamaño. |
| Espacio adicional | En el lugar, no necesita espacio adicional. | No está colocado: necesita espacio adicional para almacenar la matriz auxiliar. |
| Método de clasificación | Interno: los datos se ordenan en la memoria principal. | Externa: utiliza memoria externa para almacenar matrices de datos. |
| Eficiencia | Más rápido y eficiente para listas de tamaño pequeño. | Rápido y eficiente para listas más grandes. |
| Matrices / listas enlazadas | Más preferido para matrices. | Funciona bien para listas enlazadas. |
Conclusión
Como sugiere su propio nombre, quicksort es el algoritmo que ordena la lista más rápido que cualquier otro algoritmo de ordenación. Al igual que la ordenación por combinación, la ordenación rápida también adopta una estrategia de dividir y conquistar.
Como ya hemos visto, usando la ordenación rápida dividimos la lista en submatrices usando el elemento pivote. Luego, estas submatrices se ordenan de forma independiente. Al final del algoritmo, toda la matriz está completamente ordenada.
Quicksort es más rápido y funciona de manera eficiente para ordenar estructuras de datos. Quicksort es un algoritmo de clasificación popular y, a veces, incluso se prefiere al algoritmo de clasificación por fusión.
En nuestro próximo tutorial, discutiremos más sobre la ordenación de Shell en detalle.
=> Tenga cuidado con la serie de capacitación simple de C ++ aquí.
Lectura recomendada
- Método MongoDB Sort () con ejemplos
- Comando de ordenación de Unix con sintaxis, opciones y ejemplos
- Combinar ordenación en C ++ con ejemplos
- Ordenar montón en C ++ con ejemplos
- Orden de Shell en C ++ con ejemplos
- Orden de selección en C ++ con ejemplos
- Clasificación de burbujas en C ++ con ejemplos
- Orden de inserción en C ++ con ejemplos