Todo lo que necesita saber sobre Quicksort en C ++

Hay una gran cantidad de algoritmos de clasificación. Encontrar el ajuste adecuado para su aplicación es una tarea que requiere una breve comprensión de factores como el rendimiento, la complejidad del tiempo, la longitud del código, etc. de un algoritmo en particular. En esta publicación, veremos todos los conceptos esenciales necesarios para implementar Quicksort en C ++ en el siguiente orden:

• Comprensión del algoritmo Quicksort
• Pseudocódigo para Quicksort
• Programa de Quicksort en C ++
• Clasificación rápida de complejidad de tiempo

Comprensión del algoritmo Quicksort

Al igual que Combinar ordenar , Quicksort sigue la estrategia de divide y vencerás. Al usar la estrategia de divide y vencerás, dividimos el problema en muchos subproblemas y los resolvemos de forma recursiva. Primero, entenderemos todo el proceso paso a paso y luego, con la ayuda de un ejemplo, desarrollaremos una comprensión profunda de todo el proceso.

1. Primero, le pediremos al usuario la matriz sin clasificar.

2. Una vez que tengamos nuestra matriz sin clasificar, debemos seleccionar un valor de pivote de la matriz. Podemos elegir cualquier valor.

   
   
   

3. Una vez que seleccionamos el punto de pivote, necesitamos organizar los otros elementos de la matriz de tal manera que todos los elementos menores que el valor de pivote deben colocarse a la derecha del valor de pivote y todos los elementos mayores que el pivote. El valor se colocará a la derecha del valor pivote.

4. Realizamos el paso 3 hasta que obtengamos nuestra matriz ordenada.

Ahora, consideremos un ejemplo e implementemos el algoritmo y veamos cómo funciona.

Hola [5, 4, 1, 11, 9, 6, 2, 3] para este ejemplo, siempre consideraremos el pivote como el elemento más a la derecha de la lista.

cómo salir en java

Repasemos cada paso y entendamos la lógica que usamos para resolver el problema.

• Primero, seleccionamos '3' como nuestro pivote y organizamos todos los elementos menores que '3' a la derecha y todos los elementos mayores que '3' a la derecha.

• En este punto, tenemos 2 subproblemas. Primero resolvamos el subproblema de la derecha. Seleccionamos uno como nuestro pivote y colocamos '2' a la derecha.

• Para resolver el segundo subproblema, seleccionamos '6' como pivote y colocamos los elementos como comentamos anteriormente.

• Tenemos 2 subproblemas más. El primero se resuelve seleccionando 4 como pivote y el segundo se resuelve seleccionando 9 como pivote. Finalmente, tenemos nuestra matriz ordenada con los elementos colocados en el índice subrayado.

Nota- El punto importante a entender aquí es que todas las operaciones tienen lugar en la misma matriz. No se crean nuevas matrices.

Pseudocódigo para Quicksort en C ++

QuickSort (matriz [], índice_inicio, índice_final) {if (índice_inicio
 Programa de Quicksort en C ++ 
Entendimos el algoritmo y desarrollamos una comprensión profunda del funcionamiento del algoritmo. Implementemos Quicksort en C ++ y escribamos un programa para ordenar una matriz.
#include usando el espacio de nombres std void swap_elements (int * a, int * b) {int temp = * a * a = * b * b = temp} int partición (int array [], int start_index, int end_index) {int pivot = array [end_index] int i = (start_index - 1) for (int j = start_index j<= end_index- 1 j++) { if (array[j] <= pivot) { i++ swap_elements(&array[i], &array[j]) } } swap_elements(&array[i + 1], &array[end_index]) return (i + 1) } void quickSort(int array[], int start_index, int end_index) { if (start_index < end_index) { int partition_index = partition(array, start_index, end_index) quickSort(array, start_index, partition_index - 1) quickSort(array, partition_index + 1, end_index) } } void printArray(int array[], int number) { int i cout<<'Sorted Array: ' for (i = 0 i < number i++) cout << array[i] << ' ' cout << endl } int main() { int Hello[30] int i int NumberofElements cout<>Costo de NumberofElements<<'Enter the elements one by one: ' for(i=0i>Hola [i]} quickSort (Hola, 0, NumberofElements-1) printArray (Hola, NumberofElements) return 0}
 Salida: 
 Complejidad del tiempo 
Hablemos del aspecto más importante de cualquier algoritmo de clasificación, es decir, la complejidad del tiempo. Nos informa sobre el rendimiento del algoritmo en varios escenarios. Estos valores pueden ayudarnos a decidir si podemos utilizar este algoritmo para nuestra aplicación.
 Mejor caso- En)
 Caso promedio (nlogn)
 Peor de los casos- En2)
Con esto, llegamos al final de este artículo de Quicksort en C ++. Si desea obtener más información, consulte el   por Edureka, una empresa de aprendizaje en línea de confianza. El curso de certificación y capacitación Java J2EE y SOA de Edureka está diseñado para capacitarlo en conceptos básicos y avanzados de Java junto con varios marcos de Java como Hibernate y Spring.
 Tienes una pregunta para nosotros? Menciónelo en la sección de comentarios de este blog y nos pondremos en contacto con usted lo antes posible.