Como uno de los algoritmos más básicos, el algoritmo de clasificación rápida también es nuestro algoritmo más utilizado. C++ también viene con uno de los algoritmos de clasificación rápida para facilitar nuestro uso. Hoy aprenderemos juntos el principio de la clasificación rápida simple.
El P1271 de Luogu es un tema así. El hecho es que antes de anoche, nunca había entendido el principio de la clasificación rápida. Cuando me encontré con este problema anoche, revisé un poco de información y obtuve una comprensión general del principio de la clasificación rápida. En realidad, es para la clasificación de burbujas. Una optimización, primero seleccione un valor especial de la matriz que debe ordenarse, compare el resto de los números con él, deje el pequeño a un lado y el grande a un lado, para que cambiemos la matriz que debe ordenarse de uno a dos, y luego realice la misma operación en las dos matrices, recursivamente, y las matrices se pueden ordenar.
No es difícil sentir del proceso que, para algunos casos especiales, la eficiencia de este algoritmo es realmente muy baja. Por ejemplo, si usa este tipo de operación, necesita realizar n veces cuadradas, por lo que lo ideal en el caso , la complejidad temporal de este algoritmo es
O(logn), en el peor de los casos, su complejidad temporal es O(n^2).
Mi algoritmo de clasificación escrito a mano solo obtuvo 60 puntos cuando lo envié. Hubo dos casos en los que se agotó el tiempo de espera. Uno era un conjunto de datos que ya se habían clasificado y el otro era exactamente la misma información, lo cual es realmente canceroso.
¡El anciano está tan enojado!
Aprendiendo de nuevo, obtuve una plantilla de clasificación rápida muy simple de las hermanas del grupo ACM. Los dos conjuntos de códigos se muestran a continuación.
El primer grupo es mi fila rápida de mala calidad. Está escrito de acuerdo con los principios básicos. Puede que no esté bien escrito. También espero que alguien que encuentre errores pueda corregirlos.
#include<bits/stdc++.h>
using namespace std;
int partions(int *a,int first,int last){
int l=first;
int r=last-1;
int comparisonValue=a[last];
while(1){
while(a[l]<comparisonValue)l++;
while(a[r]>comparisonValue)r--;
if(l>=r)break;
else {swap(a[l],a[r]);l++;r--;}
}
swap(a[l],a[last]);
return l;
}
void sp_sort(int *a,int first,int last){
int p=0;
if(last-first<=0)return;
else{
p=partions(a,first,last);
sp_sort(a,first,p-1);
sp_sort(a,p+1,last);
}
}
int main(void)
{ int n;
int a[100001];
scanf("%d",&n);
for(int i=0;i<n;i++)scanf("%d",&a[i]);
sp_sort(a,0,n-1);
for(int i=0;i<n;i++)printf("%d ",a[i]);
return 0;
}La siguiente es la plantilla de la hermana mayor utilizada.
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int a[N];
void quick_sort(int *a,int l,int r){
if(l>=r)return;
int x=a[(l+r+1)/2],i=l-1,j=r+1;
while(i<j)
{
do i++;while(a[i]<x);
do j--;while(a[j]>x);
if(i<j)swap(a[i],a[j]);
}
quick_sort(a,l,i-1);
quick_sort(a,i,r);
}
int main(void)
{ int n;
scanf("%d",&n);
for(int i=0;i<n;i++)scanf("%d",&a[i]);
quick_sort(a,0,n-1);
for(int i=0;i<n;i++)printf("%d ",a[i]);
return 0;
}Es otro día para Bengoonemo.