ejemplo base class2-- ley fortuna dejada fila clásico 2 rápida, fila la bandera holandesa mejorar rápido, rápido fila al azar en C ++
1. La fila rápida clásica
análisis
Ideas holandeses bandera y los problemas en el título preliminar de la misma.
1. En primer lugar, el último elemento de la matriz como un num [l, r] en Comparativo dar dos regiones, cada región y la región o menos más grande que el último número de la última número.
2. En la región por encima del párrafo primero, el último valor de un num número de la izquierda intacto, el número de la penúltima num cambiado de nombre, entonces la comparación continúa, la iteración continúa.
3. En la región de dicha segunda sección 1, un número de la última num llamado, entonces la comparación continúa, la iteración continúa.
4. Continuar iteración de condicionesif(l<r)
código del núcleo
1. porción de clasificación
devuelve un valor x-1: menos de o igual a devolver la posición penúltima de las posiciones de rango, la última posición es la num original, directamente al lado penúltima posición como el siguiente num.
int partition(int arr[],int l,int r)
{
int num = arr[r]; //把最后一个数设为num进行比较
int x = l-1; //x为小于等于的区域，设为区域之前一个位置
int cur = l; //cur是当前遍历的指针
while(cur < r+1) //遍历所有位置
{
if(arr[cur]<=num)
{
swap(arr[cur++],arr[++x]);
}
else
cur++;
}
return x-1; }```
2.迭代部分
迭代的条件是在[l,r]范围内，如果越界表示不可继续分
```cpp
void quicksort(int arr[],int l,int r)
{
if(l<r)
{
int a = partition(arr,l,r);
quicksort(arr,l,a);
quicksort(arr,a+1,r);
}
}
El código completo
#include<iostream>
#include<time.h>
#define length 10
using namespace std;
//交换函数
void swap(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
int partition(int arr[],int l,int r)
{
int num = arr[r]; //把最后一个数设为num进行比较
int x = l-1; //x为小于等于的区域，设为区域之前一个位置
int cur = l; //cur是当前遍历的指针
while(cur < r+1) //遍历所有位置
{
if(arr[cur]<=num)
{
swap(arr[cur++],arr[++x]);
}
else
cur++;
}
return x-1;
}
void quicksort(int arr[],int l,int r)
{
if(l<r)
{
int a = partition(arr,l,r);
quicksort(arr,l,a);
quicksort(arr,a+1,r);
}
}
int main()
{
//准备随机数组
int arr[length] ;
srand((unsigned)time(NULL));
cout<<"arr = ";
for(int i = 0;i < length;i++)
{
arr[i] = rand()%10;
cout<<arr[i]<<" ";
}
cout<<endl;
//意外情况直接返回(本题用不到)
if (arr == NULL || length < 2)
{
return 0 ;
}
//核心
quicksort(arr,0,length - 1);
//结果输出
cout<<"arr = ";
for(int i = 0;i<length;i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
system("pause");
return 0 ;
}
2. Mejora de la fila rápida clásico de la bandera holandesa
análisis
Clásico fila rápida desventaja: sólo para encontrar un tipo num, núm Si hay varios valores idénticos también tienen que seguir dividir y hacer el trabajo más útil. Si se tiene en cuenta el método usando la bandera de los Países Bajos el pedido, el mismo tiempo num para averiguar, entonces el tiempo constante de tiempo complejidad puede ser reducida.
código del núcleo
Holandesa bandera problema requiere dos manos y un margen de registro de menos de num num intervalo de más, considere la posibilidad de definir una matriz de longitud 2 del registro, como el siguiente paso devuelve una matriz de punteros.
void quicksort(int arr[],int l,int r)
{
int a[2] = {0};
if(l<r)
{
int *p = paitition(arr,l,r,a);
quicksort(arr,l,*p);
quicksort(arr,*(p+1),r);
}
}
int* paitition(int arr[],int l,int r,int a[])
{
int x = l-1;
int y = r+1;
int cur = l;
int num = arr[r];
while(cur<y)
{
if(arr[cur]<num)
{
swap(arr[cur++],arr[++x]);
}
else if(arr[cur]>num)
{
swap(arr[cur],arr[--y]);
}
else
{
cur++;
}
}
a[0] = x;
a[1] = y;
return a;
}
El código completo
#include<iostream>
#include<time.h>
#define length 20
using namespace std;
void swap(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
int* paitition(int arr[],int l,int r,int a[])
{
int x = l-1;
int y = r+1;
int cur = l;
int num = arr[r];
while(cur<y)
{
if(arr[cur]<num)
{
swap(arr[cur++],arr[++x]);
}
else if(arr[cur]>num)
{
swap(arr[cur],arr[--y]);
}
else
{
cur++;
}
}
a[0] = x;
a[1] = y;
return a;
}
void quicksort(int arr[],int l,int r)
{
int a[2] = {0};
if(l<r)
{
int *p = paitition(arr,l,r,a);
quicksort(arr,l,*p);
quicksort(arr,*(p+1),r);
}
}
int main()
{
//生成随机数组
int arr[length];
srand((unsigned)time(NULL));
cout<<"arr = ";
for(int i = 0;i<length;i++)
{
arr[i] = rand()%10;
cout<<arr[i]<<" ";
}
cout<<endl;
quicksort(arr,0,length - 1);
//打印结果
cout<<"arr1 = ";
for(int i = 0;i<length;i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
system("pause");
return 0;
}
3. fila aleatorio rápido
análisis
Mejora de la bandera clásico holandés rápida drenar la desventaja de que el número utilizado como el último num, por ejemplo [1,2,3,4,5,6] es alta en complejidad, ya que la complejidad de las condiciones asociadas a los datos.
Tenga en cuenta: número aleatorio seleccionado en la matriz como una num, por lo que puede pasar por alto el estado de los datos en bruto, la complejidad se convierte en un expectativas a largo plazo.
código del núcleo
valor numérico en una inicialización aleatoria
int num = arr[l+rand()%(r-l+1)];
El código completo
#include<iostream>
#include<time.h>
#define length 20
using namespace std;
void swap(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
int* paitition(int arr[],int l,int r,int a[])
{
int x = l-1;
int y = r+1;
int cur = l;
int num = arr[l+rand()%(r-l+1)];
while(cur<y)
{
if(arr[cur]<num)
{
swap(arr[cur++],arr[++x]);
}
else if(arr[cur]>num)
{
swap(arr[cur],arr[--y]);
}
else
{
cur++;
}
}
a[0] = x;
a[1] = y;
return a;
}
void quicksort(int arr[],int l,int r)
{
int a[2] = {0};
if(l<r)
{
int *p = paitition(arr,l,r,a);
quicksort(arr,l,*p);
quicksort(arr,*(p+1),r);
}
}
int main()
{
//生成随机数组
int arr[length];
srand((unsigned)time(NULL));
cout<<"arr = ";
for(int i = 0;i<length;i++)
{
arr[i] = rand()%100;
cout<<arr[i]<<" ";
}
cout<<endl;
quicksort(arr,0,length - 1);
//打印结果
cout<<"arr1 = ";
for(int i = 0;i<length;i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
system("pause");
return 0;
}
Análisis de la complejidad
complejidad Tiempo de O (N logN), la complejidad espacio adicional de O (logN)
1. Para la opción de plazo largo, la posibilidad de valor un aleatorio intermedio al máximo, pensó partición T (n) = 2T (N / 2) + O (n), el tiempo de complejidad de O (N logN).
2. Encontrar un azar, la mitad del número de veces que el número de puntos de interrupción, el mejor de los casos O (logN), el peor es O (N), la probabilidad de largo plazo O (logN).
