La clasificación rápida es un método de clasificación de uso común.
La idea de clasificación rápida es:
Primero seleccione un valor de referencia en la matriz. La función de este valor de referencia es dividir toda la matriz en dos partes. Todos los valores menores que este valor de referencia se encuentran a la izquierda del valor de referencia, y todos los valores mayores que este valor de referencia están a la derecha del valor de referencia.
| Menos que el valor de referencia | Referencia | Parte mayor que el valor de referencia |
Luego use el mismo método para la parte menor que el valor de referencia y la parte mayor que el valor de referencia. Hasta que esta parte ya no se pueda dividir. Este es el algoritmo de clasificación rápida.
Ejemplo: Dada una matriz de enteros, use el método rápido para ordenar.
A continuación, comience a clasificar rápidamente. El valor predeterminado es el orden ascendente.
Los siguientes son los datos originales, hay 10 elementos en total. Registrado como:
int originalData[10];El contenido de la matriz se muestra a continuación.
| 1 | 10 | 3 | -12 | 51 | 23 | 1 | 4 | 12 | 4 |
primera ronda:
1. Seleccione un valor de referencia y regístrelo como
int standardValue;Aquí tomamos el elemento en la primera posición como valor de referencia, luego
standardValue = 1;2. Se requieren dos subíndices para acceder al elemento. Uno se llama cursor izquierdo, que se inicializa en 0, el otro se llama cursor derecho, que se inicializa en 9 (longitud de matriz -1);
Registrado como:
Cursor izquierdo
int leftIndex = 0;Cursor derecho
int rightIndex = 9;3. Deje que el cursor derecho se mueva de derecha a izquierda y busque un valor menor que el valor de referencia standardValue durante el movimiento. Cuando se encuentra ese valor, en este momento
rightIndex = 3;
originalData[rightIndex] = -12 < standardValue = 1;4. Coloque el valor de la posición indicada por el cursor derecho en la posición indicada por el cursor izquierdo; es decir
originalData[leftIndex] = originalData[rightIndex];La situación de la matriz es la siguiente:
standardValue = 1;
leftIndex = 0;
rightIndex = 3;El contenido de la matriz se muestra a continuación.
| -12 | 10 | 3 | -12 | 51 | 23 | 1 | 4 | 12 | 4 |
5. Deje que el cursor izquierdo se mueva de izquierda a derecha y encuentre un valor mayor que el valor de referencia standardValue durante el movimiento. Cuando se encuentra ese valor, en este momento
leftIndex = 1;
originalData[leftIndex] = 10 > standardValue = 1;6. Coloque el valor de la posición indicada por el cursor izquierdo en la posición indicada por el cursor derecho; a saber
originalData[rightIndex] = originalData[leftIndex];La situación de la matriz es la siguiente:
standardValue = 1;
leftIndex = 1;
rightIndex = 3;| -12 | 10 | 3 | 10 | 51 | 23 | 1 | 4 | 12 | 4 |
7. Deje que el cursor derecho se mueva de derecha a izquierda y busque un valor menor que el valor de referencia standardValue durante el movimiento. No se encontró el resultado.
cuando
leftIndex = rightIndexCuándo termina esta ronda de clasificación. en este momento
leftIndex = rightIndex = 1;| -12 | 10 | 3 | 10 | 51 | 23 | 1 | 4 | 12 | 4 |
Es necesario volver a poner el valor de referencia en la matriz. cual es
originalData[leftIndex] = standardValue = 1;En este momento, el contenido de la matriz es el siguiente:
| -12 | 1 | 3 | 10 | 51 | 23 | 1 | 4 | 12 | 4 |
Segunda ronda:
Usando el valor del elemento 1 como línea, divida la matriz en dos partes. La parte izquierda es menor o igual a 1 y la parte derecha es mayor o igual que 1.
| -12 | 1 | 3 | 10 | 51 | 23 | 1 | 4 | 12 | 4 |
Trate la submatriz en el lado izquierdo de la matriz (la parte amarilla) como una nueva matriz y realice la misma operación.
| -12 |
La submatriz de la izquierda ya está ordenada.
Trate la submatriz en el lado derecho de la matriz (la parte azul) como una nueva matriz y realice la misma operación.
| 3 | 10 | 51 | 23 | 1 | 4 | 12 | 4 |
Con el mismo procedimiento, obtendrá el resultado que se muestra a continuación.
| 1 | 3 | 51 | 23 | 10 | 4 | 12 | 4 |
La tercera ronda:
Usando el valor del elemento 3 como línea, divida la matriz en dos partes. La parte izquierda es menor o igual que 3 y la parte derecha es mayor o igual que 3.
Trate la submatriz en el lado izquierdo de la matriz (la parte amarilla) como una nueva matriz y realice la misma operación.
| 1 |
Trate la submatriz en el lado derecho de la matriz (la parte azul) como una nueva matriz y realice la misma operación.
| 51 | 23 | 10 | 4 | 12 | 4 |
Con el mismo procedimiento, obtendrá el resultado que se muestra a continuación.
| 4 | 23 | 10 | 4 | 12 | 51 |
Cuarta ronda:
Usando el valor del elemento 51 como una línea, divida la matriz en dos partes. La parte izquierda es menor o igual que 51 y la parte derecha es mayor o igual que 51.
Ahora solo queda la parte izquierda.
Trate la submatriz en el lado izquierdo de la matriz (la parte amarilla) como una nueva matriz y realice la misma operación.
| 4 | 23 | 10 | 4 | 12 |
Con el mismo procedimiento, obtendrá el resultado que se muestra a continuación.
| 4 | 23 | 10 | 4 | 12 |
Quinta ronda:
Usando el valor del elemento 4 como línea, divida la matriz en dos partes. La parte izquierda es menor o igual que 4 y la parte derecha es mayor o igual que 4.
Ahora solo queda la parte derecha.
| 23 | 10 | 4 | 12 |
Con el mismo procedimiento, obtendrá el resultado que se muestra a continuación.
| 12 | 10 | 4 | 23 |
Sexta ronda:
Usando el valor del elemento 23 como línea, divida la matriz en dos partes. La parte izquierda es menor o igual que 23 y la parte derecha es mayor o igual que 23.
Ahora solo queda la parte izquierda.
| 12 | 10 | 4 |
Con el mismo procedimiento, obtendrá el resultado que se muestra a continuación.
| 4 | 10 | 12 |
Séptima ronda:
Usando el valor del elemento 12 como línea, divida la matriz en dos partes. La parte izquierda es menor o igual que 12 y la parte derecha es mayor o igual que 12.
Ahora solo queda la parte izquierda.
| 4 | 10 |
La matriz restante ahora está en orden.
Y todos los elementos ya están en orden, así que la tarea ha terminado.
Coloque estas submatrices juntas en orden de posición para obtener la siguiente matriz.
| -12 | 1 | 1 | 3 | 4 | 4 | 10 | 12 | 23 | 51 |
La matriz original es:
| -12 | 10 | 3 | 10 | 51 | 23 | 1 | 4 | 12 | 4 |
La clasificación obtuvo el resultado ascendente correcto. (Los valores iguales no cambian la posición relativa, por lo que es un algoritmo de clasificación estable).
La implementación del código C ++ se proporciona a continuación, y el código fuente es solo para referencia.
#include <iostream>
using namespace std;
// 前向声明.
void quickSort(int *originalArray, int leftIndex, int rightIndex);
int main()
{
// 整数的个数.
int numbers = 0;
cin >> numbers;
// 保存整数的数组.
int *originalData = new int[numbers];
// 从标准输入中读取数据.
for (int i = 0; i < numbers; ++i)
{
cin >> originalData[i];
}
// 对数据进行排序.
// 使用二分排序法.
quickSort(originalData, 0, numbers - 1);
// 输出最小值和最大值.
cout << originalData[0] << " " << originalData[numbers - 1] << endl;
return 0;
}
void quickSort(int *originalArray, int leftIndex, int rightIndex)
{
// leftIndex 的备份.
int backLeft = leftIndex;
// rightIndex 的备份.
int backRight = rightIndex;
// 递归结束条件.
if (leftIndex > rightIndex)
{
// nothing to do.
}
else
{
// 参考标准.
int standardValue = originalArray[leftIndex];
while (leftIndex < rightIndex)
{
// 在 middleIndex 的右边部分,从后往前找到一个比 middleIndex 元素值小的元素.
while (leftIndex < rightIndex)
{
if (originalArray[rightIndex] >= standardValue)
{
// next element.
--rightIndex;
}
else
{
break;
}
}
originalArray[leftIndex] = originalArray[rightIndex];
// 在 middleIndex 的左边部分,从前往后找到一个比 middleIndex 元素值大的元素.
while (leftIndex < rightIndex)
{
if (originalArray[leftIndex] <= standardValue)
{
// next element.
++leftIndex;
}
else
{
break;
}
}
originalArray[rightIndex] = originalArray[leftIndex];
}
// 保存标准值.
originalArray[leftIndex] = standardValue;
// 递归调用自身.
quickSort(originalArray, backLeft, leftIndex - 1);
quickSort(originalArray, leftIndex + 1, backRight);
}
}
El siguiente es el código Java, el código fuente es solo para referencia.
import java.util.Arrays;
import java.util.Scanner;
public class QuickSort
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
int numbers = Integer.parseInt(scanner.nextLine());
int[] originalArray = new int[numbers];
for (int i = 0; i < numbers; ++i)
{
originalArray[i] = scanner.nextInt();
}
quickSort(originalArray, 0, numbers - 1);
System.out.println(Arrays.toString(originalArray));
scanner.close();
}
public static void quickSort(int[] originalData, int leftIndex, int rightIndex)
{
int backLeft = leftIndex;
int backRight = rightIndex;
if (leftIndex > rightIndex)
{
// nothing to do.
}
else
{
int standardValue = originalData[leftIndex];
while (leftIndex < rightIndex)
{
while (leftIndex < rightIndex)
{
if (originalData[rightIndex] >= standardValue)
{
// next element.
--rightIndex;
}
else
{
break;
}
}
originalData[leftIndex] = originalData[rightIndex];
while (leftIndex < rightIndex)
{
if (originalData[leftIndex] <= standardValue)
{
// next element.
++leftIndex;
}
else
{
break;
}
}
originalData[rightIndex] = originalData[leftIndex];
}
originalData[leftIndex] = standardValue;
// 递归调用自身.
quickSort(originalData, backLeft, leftIndex - 1);
quickSort(originalData, leftIndex + 1, backRight);
}
}
}
¡Terminado!