Ordenar rápida (paradigma del intercambio)
código de clasificación rápida, básicamente, de nuevo en él, prestar atención a> = y <= opinión personal, pero también pueden estar sin tiempo de espera.
// 一趟快排就是找到第一个元素的位置使得左边比它小右边比它大
int _quicksort(int *a, int low, int high) {
int mid_value = a[low];
while(low < high) {
while(low < high && a[high] >= mid_value) high--;
a[low] = a[high];
while(low < high && a[low] <= mid_value) low++;
a[high] = a[low];
}
a[low] = mid_value;
return low;
}
void quicksort(int *a, int low, int high) {
if (low < high) {
int mid = _quicksort(a, low, high);
quicksort(a, low, mid-1);
quicksort(a, mid+1, high);
}
}
Burbuja Sort (paradigma del intercambio)
void bubblesort(int *a, int n) {
for(int i=0; i<n-1; i++) {
int flag = 0;
for(int j=n-1; j>i; j--) {
if (a[j-1] > a[j]) {
int tmp = a[j-1];
a[j-1] = a[j];
a[j] = tmp;
flag = 1;
}
}
if (!flag) return;
}
}
ordenación por inserción directa (inserción Paradigma)
No publicado código relativamente simple, el segundo elemento de la matriz es de un inicio de la próxima iteración, se encuentra un valor para ser insertado después de la entera precedente matriz ordenada.
Colina de clasificación (inserto paradigma)
La pregunta no tiene que escribir el código, por ejemplo, un viaje en incrementos de 3 de clasificación sub-procesos:
第0步 15 9 7 8 20 -1 4
第1步 15 8 4 -> 4 8 5
第2步 9 20 -> 9 20
第3步 7 -1 -> -1 7
（每一步都用直接插入排序获取）
第一趟得到: 4 9 -1 8 20 7 5
Sobre esta base, la colina de la clasificación sigue el siguiente procedimiento:
- De incrementos de n / 2 comienza, tiempos incrementales por reducir a la mitad las operaciones anteriores hasta que un incremento final de un extremo de ese viaje.
Seleccione clasificación (paradigma de selección)
Muy simple, si de pequeño a grande, comenzando con el índice 0 hasta el final, en cada paso de la selección en la posición actual del índice detrás mínima.
Heapsort (elija paradigma)
Empuje ordenar la matriz visto como un árbol binario completo, el medio de la raíz del árbol binario Fengyun cualquier padre montón es siempre mayor que el nodo secundario.
árbol binario completo es que cada elemento de la matriz con el fin de llenar un árbol binario completo.
Construido gran proceso de pila de la raíz:
- Desde el último nodo no hoja, desde el ajuste al alza parte inferior de cada nodos que no son hojas (derecha a izquierda de abajo a arriba)
- Ajuste:. Si el nodo actual es mayor que la necesidad de ajustar dos hijos lo contrario, encontrar el mayor valor al hijo con su intercambio, y luego ajustar el hijo hasta los nodos hoja.
proceso de pila de clasificación (después de completar la construcción de la pila):
void heapsort(int *a, int n) {
build_maxheap(a, n);
for(int i=n-1; i>0; i--) {
swap(a[0], a[i]); // 从后往前迭代，每次将堆顶输出到当前位置, 排序后为从小到大
adjust(a, i-1);
}
}
Combinar especie
algoritmo de combinación es muy importante, se recomienda un poco hacia atrás, su función es la de fusionar dos matriz ya ordenada, el orden de salida.
void merge(int *a, int low, int mid, int high, int *buffer) {
// a[low:mid] 与 a[mid+1:high] 各自有序, 现在要输出一个有序的a[low:high]
int i, j, k;
for (k=low; k<=high; k++) buffer[k] = a[k]; //拷贝
for (i=low, j=mid+1, k=low; k<=mid && j<=high; k++) {
// i,j为两个有序数组的扫描指针, k为当前输出指针
if (buffer[i] <= buffer[j]) a[k] = buffer[i++];
else a[k] = buffer[j++];
}
while(i<=mid) a[k++] = buffer[i++];
while(j<=high) a[k++] = buffer[j++];
}
int *buffer = new int[n] // 需要开一个和输入一样大的数组
void mergesort(int *a, int low, int high) {
if (low<high) {
int mid = (low+high)/2;
mergesort(a, low, mid);
mergesort(a, mid+1, high);
merge(a, low, mid, high, buffer); //归并放最后，这个算法是自底向上的
}
}
Radix sort
grupo decimal, el radix prioridad más baja proceso de clasificación:
- La creación de 10 colas
- Según introducir toda la última (10%), colocado en las colas (por ejemplo 123 se coloca en la cola de la cola No. 3)
- 0-10 los valores de salida respectivos de la cola
- Y luego se coloca en una cola de acuerdo con la penúltima posición (similar a la operación 2)
- 0-10 los valores de salida respectivos de la cola
- Se continúa hasta el final de la operación-bit más alto
Características algoritmo de ordenación de la tabla
| algoritmo | La complejidad de la mejor | complejidad media | peor complejidad | espacio complejidad | estabilidad |
|---|---|---|---|---|---|
| ordenación por inserción directa | O (n) | O (n ^ 2) | O (n ^ 2) | O (1) | Y |
| Ordenar burbuja | O (n) | O (n ^ 2) | O (n ^ 2) | O (1) | Y |
| selección Ordenar | O (n ^ 2) | O (n ^ 2) | O (n ^ 2) | O (1) | |
| la ordenación Shell | O (1) | ||||
| Ordenación rápida | O (nlogn) | O (nlogn) | O (n ^ 2) | O (log n) | |
| heapsort | O (nlogn) | O (nlogn) | O (nlogn) | O (1) | |
| 2 vías de combinación especie | O (nlogn) | O (nlogn) | O (nlogn) | O (n) | Y |
| Radix sort | O (d (n + r)) | O (d (n + r)) | O (d (n + r)) | (R) | Y |