**
Resumen de clasificación de inserción
1. Clasificación por inserción directa
Características del algoritmo:
1. Clasificación estable
2. También es adecuado para la estructura de la cadena, pero no hay necesidad de mover registros en la lista enlazada individualmente, simplemente modifique el puntero correspondiente.
3. Es más adecuado para situaciones en las que los registros iniciales están básicamente en orden. Cuando los registros iniciales están desordenados y n es grande, no es adecuado.
4. Complejidad temporal O (n * n), complejidad espacial O (1);
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
void InsertSort(int *a,int length){
int j;
for(int i=1;i<length;i++){
int t=a[i];
for(j=i-1;j>=0;j--){
if(t<a[j]){
a[j+1]=a[j];
}else break;
}
a[j+1]=t;
}
}
int main()
{
int a[10]={
49,38,65,97,76,13,27,49,55,04};
InsertSort(a,10);
for(int i=0;i<10;i++)
cout <<a[i]<<" ";
return 0;
}
2. Clasificación por inserción binaria
Características del algoritmo:
1. Clasificación estable
2. Debido a que se requiere la búsqueda binaria, solo se puede estructurar en secuencia, no en cadena.
3. Es adecuado para la situación en la que el registro inicial está desordenado y n es grande.
4. Complejidad temporal o (n), complejidad espacial o (1);
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
void BInsertSort(int *a,int length){
int j;
for(int i=1;i<length;i++){
int t=a[i];
int low=0,high=i-1;
while(low<=high){
if(t<a[(low+high)/2]) high=(low+high)/2-1;
else low=(low+high)/2+1;
}
for(j=i-1;j>=low;j--){
a[j+1]=a[j];
}
a[low]=t;
}
}
int main()
{
int a[10]={
49,38,65,97,176,13,27,49,55,04};
BInsertSort(a,10);
for(int i=0;i<10;i++)
cout <<a[i]<<" ";
return 0;
}
3. Características del algoritmo de clasificación de colinas
: el
movimiento de salto conduce a la inestabilidad. Solo
se puede usar en una estructura secuencial, no en una estructura de cadena.
La matriz incremental puede tener múltiples opciones, pero el valor en el incremento no debe ser otro que 1. El común factor de, y el último incremento debe ser 1; el
número total de comparaciones y el número de movimientos es menor que el de la ordenación por inserción directa, cuanto mayor sea la n, más obvio será el efecto. Por lo tanto, es adecuado para la situación en la que el registro inicial está desordenado y n es grande.
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
void ShellInsert(int a[],int dt,int length){
int t,j;
for(int i=dt;i<length;i++)
if(a[i]<a[i-dt]){
t=a[i];
for(j=i-dt;j>=0&&a[j]>t;j=j-dt)
a[j+dt]=a[j];
a[j+dt]=t;
}
}
void ShellSort(int a[],int dt[],int t,int length){
for(int i=0;i<t;i++){
ShellInsert(a,dt[i],length);
}
}
int main()
{
int a[10]={
49,38,65,97,76,13,27,49,55,04};
int dt[3]={
5,3,1};
ShellSort(a,dt,3,10);
for(int i=0;i<10;i++)
cout <<a[i]<<" ";
return 0;
}