Algoritmo de clasificación
Como introducción al algoritmo, debes dominar el algoritmo de clasificación. Estoy empezando a cepillar el algoritmo. Empecemos a describir el historial de mi algoritmo desde aquí.
冒泡排序
Complejidad O (n2)
- Descripción del algoritmo
1. El bucle externo 0-n significa que n elementos deben coincidir una vez.
2. El internoj = n-1-jdebe hacer coincidir un elemento y reducir los elementos a comparar en uno cada vez, es decir, comparar solo el primeron-1-jde el elemento de secuencia sin clasificar .
3. En cada comparación, los elementos adyacentes se comparan y los elementos emparejados se "hunden" hasta el final, por lo que no tiene que preocuparse por eso. - Presentación dinámica
- Código
#include <iostream>
using namespace std;
void swap(int *a, int *b){
int temp = *a;
*a = *b;
*b = temp;
}
int main(int argc, char** argv){
int len;
cout << "please input arr lenth:";
cin >> len;
int arr[len];
for(int i=0; i<len; i++){
cout << "please input" << i << "num:";
cin >> arr[i];
}
for(int i=0; i<len; i++){
for(int j=0; j<len-i-1; j++){
if(arr[j] > arr[j+1]){
swap(&arr[j],&arr[j+1]);
}
}
}
for(int i=0; i<len; i++){
cout << arr[i] << " ";
}
cout << "\n";
return 0;
}
快速排序
La complejidad de la ordenación rápida de O (nlog2n) es así.
En primer lugar, a partir de un conjunto de datos como "3 2 3 5 1 9 6", la clasificación rápida se divide en los siguientes pasos para completar.
- 1. Encuentre un número base, aquí está el primer arr [0] (es decir, 3).
- 2. Para comparar, cambie el número mayor que 3 a la izquierda de 3 y el número menor que 3 a la derecha de 3.
- 3. Luego cambie la posición del valor en el momento del encuentro con el número de referencia.
- 4. Luego, usa la recursividad para ordenar los lados izquierdo y derecho respectivamente.
Nota: El lado derecho aquí debe moverse primero, porque el número de referencia es el lado izquierdo de la selección. Si se selecciona el número más a la izquierda arr [left] como el número de referencia, entonces comenzar desde el lado derecho puede asegurar que cuando i y j encuentro, el número de encuentros es menor Para el número base, el lado izquierdo de la posición de temp después del intercambio es menor que temp. Pero comenzando por la izquierda, el número de encuentros es mayor que el número de referencia, y no se puede asegurar que el número a la izquierda de la temperatura sea menor que él. Entonces, para escanear, comience desde el lado opuesto del número de referencia. por ejemplo:
初始数列：3 2 3 5 1 9 6
变换后数列：3 2 3 1 5 9 6（到这里只有1和5换了位置）
我们可以看到上面一步将1和5交换了位置，这时侯左边哨兵指向1，右边哨兵指向5，如果左边哨兵先走，
那么他就指向了5，然后停下来，右边哨兵也因为条件不满足停在了5这里，然后让3和5交换。这样逻辑就错误了，所以只能是右边先走。
- Código
#include <iostream>
using namespace std;
//快速排序（从小到大）
void quickSort(int left, int right, int * arr)
{
if(left >= right)
return;
int i, j, base, temp;
i = left, j = right;
base = arr[left]; //取最左边的数为基准数
while (i < j)
{
while (arr[j] >= base && i < j)
j--;
while (arr[i] <= base && i < j)
i++;
if(i < j)
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//基准数归位
arr[left] = arr[i];
arr[i] = base;
quickSort(left, i - 1, arr);//递归左边
quickSort(i + 1, right, arr);//递归右边
}
int main(int argc, char** agrv){
int len;
cout << "please input lenth:";
cin >> len;
int arr[len];
for(int i=0; i<len; i++){
cout << "please input num:";
cin >> arr[i];
}
quickSort(0,len-1,arr);
for(int i=0; i<len; i++){
cout << arr[i] << " ";
}
cout << "\n";
return 0;
}
插入排序
La complejidad de la
ordenación por inserción O (n2) es compararla con la anterior comenzando desde la primera, porque la cero ya se trata como una matriz ordenada. Luego comience desde el primero y compárelo con el frente, y luego retroceda.
Tome [1, 5, 4, 3, 4, 5, 6, 8] como ejemplo:
key = arr [i]
Primero, se determina que j está en buen orden, y luego comienza desde i para comparar con el anterior. uno, i> j Por lo tanto, 5 permanece sin cambios.
La segunda ronda está aquí, y luego 5> 4, por lo que la operación realizada es arr [j + 1] = arr [j], es decir, 5 se cambia a 4, y luego 4 se compara con el 1 anterior.
Entonces es así, luego compara 1 con 4, 1 <4, por lo que no hay operación.
Entonces iyj apuntan a 3 y 5 respectivamente
. Para la primera comparación , 5> 3, por lo que 5 se mueve hacia atrás
while(j>=0 && arr[j]> key){
arr[j+1] = arr[j];
j--;
}
Al comparar 4 y 3, 4> 3, por lo que 4 se desplaza hacia atrás
while(j>=0 && arr[j]> key){
arr[j+1] = arr[j];
j--;
}
Luego repita los pasos anteriores.
- Código
#include <iostream>
using namespace std;
void Insert_Sort(int *arr, int len){
int j,key;
for(int i=1; i<len; i++){
key = arr[i];
j = i-1;
while(j>=0 && arr[j]> key){
arr[j+1] = arr[j];
//swap(&arr[j+1], &arr[i]);
j--;
}
arr[j+1] = key;
//swap(&arr[j+1], &key);
}
}
int main(){
int len;
cout << "please input len:";
cin >> len;
int arr[len];
for(int i=0; i<len;i++){
cout << "please input num:";
cin >> arr[i];
}
Insert_Sort(arr,len);
for(int i=0; i<len; i++){
cout << arr[i] << " " ;
}
cout << "\n";
return 0;
}