Tabla de contenido
Orden de selección simple
La clasificación por selección simple también se denomina clasificación por selección directa .
Ideas de algoritmos
[Pasos del algoritmo]
① Suponga que se accede a los registros a ordenar en la matriz r [1 ... n]. El primer paso comienza desde r[1] y, a través de n-1 comparaciones, se selecciona el registro con la palabra clave más pequeña de los n registros, se registra como r[k] y se intercambian r[1] y r[k].
② El segundo paso comienza desde r[2], a través de n-2 comparaciones, el registro con la palabra clave más pequeña se selecciona de los n-1 registros y se registra como r[k], y r[2] y r[k] son intercambiado. .
③ Por analogía, el i-ésimo paso comienza desde r [i] y, a través de ni comparaciones, el registro con la palabra clave más pequeña se selecciona de n-i + 1 registros, como r [k], r [i] y r. [se intercambian.k].
④ Después de n-1 veces, se completa la clasificación.
Implementación de algoritmo
Definir la estructura de tabla lineal para almacenar registros.
//记录
typedef struct ElemType{
int key;
string info;
}ElemType;
#define InitSize 50
typedef struct {
ElemType data[InitSize];
int length;
}SqList;
void toString(SqList L);
void toString(SqList L,int low,int high);
void InitSqList(SqList &L);
Código
void SelectSort(SqList &L) {
ElemType min = L.data[0];
for (int i = 0; i < L.length-1; i++) {
int k = i;
cout << " -----------------第" << k+1 << "趟排序--------------------- "
<< endl;
cout << "初始min r["<< k <<"]= " << L.data[k].key
<< endl;
for (int j = i + 1; j < L.length; j++) {
if (L.data[j].key < L.data[k].key) {
k = j;
cout << "新的min r["<< k <<"]= " << L.data[k].key << endl;
}
}
if (k != i) {
swap(L.data[i], L.data[k]);
}
cout << "有序 " ;
toString(L,0,i);
cout << "待排序 " ;
toString(L,i+1,L.length-1);
}
}
Caso de prueba
void testSelectSort(){
SqList L;
InitSqList0(L);
cout <<" ----------------------------初始 L----------------------------------"<< endl;
toString(L,0,L.length-1);
SelectSort(L);
cout <<" -------------------------最终排序结果--------------------------------"<< endl;
toString(L,0,L.length-1);
}
int main() {
testSelectSort();
return 0;
}
Resultados de la prueba
----------------------------------初始 L----------------------------------------
[ 41 67 34 0 69 24 78 58 62 64 ]
-----------------------------------第1趟排序---------------------------------------
初始min r[0]= 41
新的min r[2]= 34
新的min r[3]= 0
有序 [ 0 ]
待排序 [ 67 34 41 69 24 78 58 62 64 ]
-----------------------------------第2趟排序---------------------------------------
初始min r[1]= 67
新的min r[2]= 34
新的min r[5]= 24
有序 [ 0 24 ]
待排序 [ 34 41 69 67 78 58 62 64 ]
-----------------------------------第3趟排序---------------------------------------
初始min r[2]= 34
有序 [ 0 24 34 ]
待排序 [ 41 69 67 78 58 62 64 ]
-----------------------------------第4趟排序---------------------------------------
初始min r[3]= 41
有序 [ 0 24 34 41 ]
待排序 [ 69 67 78 58 62 64 ]
-----------------------------------第5趟排序---------------------------------------
初始min r[4]= 69
新的min r[5]= 67
新的min r[7]= 58
有序 [ 0 24 34 41 58 ]
待排序 [ 67 78 69 62 64 ]
-----------------------------------第6趟排序---------------------------------------
初始min r[5]= 67
新的min r[8]= 62
有序 [ 0 24 34 41 58 62 ]
待排序 [ 78 69 67 64 ]
-----------------------------------第7趟排序---------------------------------------
初始min r[6]= 78
新的min r[7]= 69
新的min r[8]= 67
新的min r[9]= 64
有序 [ 0 24 34 41 58 62 64 ]
待排序 [ 69 67 78 ]
-----------------------------------第8趟排序---------------------------------------
初始min r[7]= 69
新的min r[8]= 67
有序 [ 0 24 34 41 58 62 64 67 ]
待排序 [ 69 78 ]
-----------------------------------第9趟排序---------------------------------------
初始min r[8]= 69
有序 [ 0 24 34 41 58 62 64 67 69 ]
待排序 [ 78 ]
-------------------------------最终排序结果--------------------------------------
[ 0 24 34 41 58 62 64 67 69 78 ]
进程已结束,退出代码0
Análisis de algoritmos
① Complejidad del tiempo:
En el proceso de clasificación por selección simple, se requieren menos movimientos de registros.
- Mejor caso (secuencia positiva): sin movimiento;
- En el peor de los casos (orden inverso): muévase 3(n-1) veces.
Sin embargo, independientemente del orden inicial de los registros, la interclave requeridaEl número de comparaciones es el mismo., ambos son
KCN=(n-1)+(n-2)+…+(3-1)+(2-1)=n(n-1)/2.
Por lo tanto,La complejidad temporal de la clasificación por selección simple es O (n ^ 2/2)。
② Complejidad espacial
Al igual que la clasificación por burbujas, solo se necesita un espacio auxiliar cuando se intercambian dos registros, por lo queLa complejidad del espacio es O (1)。
[Características del algoritmo]
① mismoestableEl método de clasificación, utilizando la estrategia de "registros de intercambio", produciráfenómeno inestable.
② Sípara estructuras de cadena.
③ El número de registros de movimiento es pequeño, cuando cada artículoLa grabación ocupa mucho espacio., la ordenación por selección simple es más rápida que la ordenación por inserción directa.