Principio y algoritmo de clasificación rápida

1. Principio de clasificación rápida

La idea básica de este método es:

• 1. Primero, tome un número de la secuencia numérica como número de referencia.
• 2. En el proceso de partición, todos los números mayores que este número se colocan en el lado derecho y todos los números menores o iguales a él se colocan en el lado izquierdo.
• 3. Repita el segundo paso para los intervalos izquierdo y derecho hasta que solo haya un número en cada intervalo.

最本质的总结:
La clasificación rápida, para decirlo sin rodeos, es el proceso de encontrar la posición correcta del índice para los datos de referencia.

Como se muestra en la figura a continuación, asumiendo que los datos de referencia iniciales son el primer elemento 23 de la matriz, primero use una variable temporal para almacenar los datos de referencia, es decir, tmp = 23; luego escanee la matriz desde ambos extremos de la matriz y establecer dos indicadores: puntos bajos a la posición inicial, puntos altos al final.
 
  
  

Primero, a partir de la segunda mitad, si el valor escaneado es mayor que los datos de referencia, sea alto menos 1. Si hay un elemento que es menor que el valor de los datos de referencia (18 <= tmp en la figura anterior), asignar el valor de la posición alta a la posición Baja, los resultados son los siguientes:
  

Luego, comience a escanear de adelante hacia atrás. Si el valor escaneado es menor que los datos de referencia, agregue 1 al mínimo. Si se encuentra que un elemento es mayor que el valor de los datos de referencia (como se muestra en la Figura 46 => tmp), luego asigne el valor de la posición baja a la posición alta. El resultado después de que el puntero se mueve y el intercambio de datos es el siguiente:

Luego comience a escanear de atrás hacia adelante. El principio es el mismo que el anterior, y se encuentra que la figura anterior 11 <= tmp, luego el valor de la posición alta se asigna al valor de la posición baja, y los resultados son como sigue:

Luego comience a recorrer de adelante hacia atrás hasta que bajo = alto termine el ciclo, en este momento el subíndice de bajo o alto es 基准数据23在该数组中的正确索引位置como se muestra en la siguiente figura.

Después de caminar de esta manera, puede saber claramente que, de hecho 快速排序的本质就是把基准数大的都放在基准数的右边,把比基准数小的放在基准数的左边,这样就找到了该数据在数组中的正确位置.
  , la primera mitad y la segunda mitad se ordenan por separado de manera recursiva en el futuro. Cuando la mitad actual y la segunda mitad estén en orden, la matriz se ordenará naturalmente .

2. Ideas de código

Puede ver en el proceso anterior:

• ① Escanee hacia adelante desde el final de la línea y cuando sea bajo <alto, si un [alto]> tmp, luego alto--, pero si un [alto] <tmp, entonces asigne el valor de alto a bajo, es decir, arr [bajo] = a [alto], al mismo tiempo, el método de escaneo de la matriz debe cambiarse, es decir, debe escanear desde el principio del equipo hasta el final del equipo
• ② De manera similar, al escanear desde la cabeza del equipo hasta el final del equipo, si un [low] <tmp, luego low ++, pero si es un [low]> tmp, debe asignar el valor de la posición baja a la posición alta Es decir, arr [bajo] = arr [alto], y al mismo tiempo cambia el modo de escaneo de matriz a escaneo desde el final de la línea hasta el principio de la línea.
• ③ Siga repitiendo ① y ②, sabiendo que bajo> = alto (en realidad bajo = alto), la posición de bajo o alto es la posición de índice correcta de los datos de referencia en la matriz ...

3. Encuentra el índice del número de referencia.

Aquí hay otra imagen para profundizar la impresión de encontrar el índice;

4. Código de referencia

import java.util.Arrays;

public class QuickSort {
    
    
	public static void main(String[] args) {
    
    
		int[] arr = {
    
     49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22 };
		quickSort(arr, 0, arr.length - 1);
		System.out.println("排序后:");
		for (int i : arr) {
    
    
			System.out.print(i + "  ");
		}
	}

	private static void quickSort(int[] arr, int low, int high) {
    
    

		if (low < high) {
    
    
			// 找寻基准数据的正确索引
			int index = getIndex(arr, low, high);
			System.out.println("排序后" + Arrays.toString(arr));
			// 进行迭代对index之前和之后的数组进行相同的操作使整个数组变成有序
			//quickSort(arr, 0, index - 1); 之前的版本，这种姿势有很大的性能问题，谢谢大家的建议
			quickSort(arr, low, index - 1);
			quickSort(arr, index + 1, high);
		}

	}

	private static int getIndex(int[] arr, int low, int high) {
    
    
		// 基准数据
		int tmp = arr[low];
		while (low < high) {
    
    
			// 当队尾的元素大于等于基准数据时,向前挪动high指针
			while (low < high && arr[high] >= tmp) {
    
    
				high--;
			}
			// 如果队尾元素小于tmp了,需要将其赋值给low
			arr[low] = arr[high];
			// 当队首元素小于等于tmp时,向前挪动low指针
			while (low < high && arr[low] <= tmp) {
    
    
				low++;
			}
			// 当队首元素大于tmp时,需要将其赋值给high
			arr[high] = arr[low];
		}
		// 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置
		// 由原理部分可以很清楚的知道low位置的值并不是tmp,所以需要将tmp赋值给arr[low]
		arr[low] = tmp;
		return low; // 返回tmp的正确位置
	}
}

Los efectos operativos son los siguientes:

---

Artículo de referencia:
https://blog.csdn.net/nrsc272420199/article/details/82587933
https://github.com/doubleview/data-structure

---

Terminar