Estructura de datos: algoritmo de clasificación común (6): clasificación rápida (implementación de C ++)

Estructura de datos: algoritmo de clasificación común (6): clasificación rápida

1. Idea básica:

Seleccione un elemento de referencia, generalmente el primer elemento o el último elemento, a través de una ronda de escaneo, la secuencia a ordenar se divide en dos partes, una es más pequeña que el elemento de referencia y la otra es mayor o igual que el elemento de referencia, y luego el elemento de referencia se ordena en él. Luego use el mismo método para ordenar las dos partes de manera recursiva hasta que solo haya un número en cada intervalo.

2. Ejemplos

Ejemplo: la matriz a [15] = {3,44,38,5,47,15,36,26,2,46,4,19,50,48} se ordena por clasificación rápida

Fuente de la imagen: https://www.cnblogs.com/zwtgyh/p/10631760.html

Código de ejemplo:

//辅助函数:交换值
void exchange(int * a, int* b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

//打印数组函数
void print_arr(int *a, int size) 
{
  cout << "打印数组：";
  for (int i = 0; i<size; i++)  //打印数组 
  {
    cout << a[i] << " ";
  }
  cout << endl << endl;
}

/*序列划分函数*/
int partition(int a[], int p, int r) {
  int key = a[r];//取最后一个
  int i = p - 1;
  for (int j = p; j < r; j++)
  { 
    if (a[j] <= key)
    {     
      i++;
      //i一直代表小于key元素的最后一个索引，当发现有比key小的a[j]时候，i+1 后交换     
      exchange(&a[i], &a[j]);
    }   
  } 
  exchange(&a[i + 1], &a[r]);//将key切换到中间来，左边是小于key的，右边是大于key的值。
  return i + 1;
}
  
void quickSort(int a[], int p, int r) {
  int position = 0;
  if (p<r)
  {
    position = partition(a,p,r);//返回划分元素的最终位置
    quickSort(a,p,position-1);//划分左边递归
    quickSort(a, position + 1,r);//划分右边递归
  } 
}
  //主函数
void main() {
  int a[15]={3,44,38,5,47,15,36,26,2,46,4,19,50,48};
  cout << "输入数组 a[15]={3,44,38,5,47,15,36,26,2,46,4,19,50,48} " << endl; 
  quickSort(a, 0, 14);
  print_arr(a, 15);
  
}

3. Resumen:

• El mejor de los casos: cada ronda de división divide la secuencia a clasificar en dos partes, por lo que el tiempo requerido para cada parte es la mitad de la ronda anterior. Si se ordena una secuencia de n elementos, la profundidad del árbol de recursividad es [logn] +1, lo que significa que solo se requieren recursiones de registros y el tiempo total requerido es T (n), la primera vez que necesita escanear la secuencia completa, hacer n comparaciones y luego La secuencia se divide en dos, y las dos partes necesitan T (n / 2) tiempo respectivamente, que se dividen en orden: T (n) = 2 T (n / 2) + n T (n) = 2 (2 * (T (n / 4) + n / 2) + n = 4 T (n / 4) + 2n y así sucesivamente, y T (1) = 0, entonces T (n) = n T (1) + n * logn = O (nlogn)
• Peor de caso: Cuando la secuencia a ordenar es una secuencia ordenada (positiva o inversa), la situación que se obtiene después de cada división es que hay 1 elemento en un lado y los elementos restantes en el otro lado, y finalmente n-1 rondas de bucle. , Y el i-ésimo ciclo necesita ni comparaciones, el número total de comparaciones es n-1 + n-2 +… + 1 = n (n-1) / 2, es decir, la complejidad del tiempo es O (n ^ 2)
• La clasificación rápida es una clasificación in situ y no requiere espacio de memoria adicional.
• La clasificación rápida no es una clasificación estable, destruirá la estabilidad durante el proceso de intercambio.