Ordenar código fuente del algoritmo
#define NUM 5 //Número de elementos de tabla desordenados
#Define MAX 1000 //Valor máximo de elementos
Usar nombres Space std
int list[NUM * 10]= { 0 }; //Almacenamiento de lista desordenada y resultados ordenados.
int merge_list[NUM * 10]= { 0 }; // Se utiliza para almacenar listas desordenadas durante la clasificación por combinación.
int merge _ link[NUM * 10]= { 0 }; //Auxiliar durante la clasificación por fusión
void init();
void init _ list (int);
void out(int[], int, int);
void swap(int, int);
//1clasificación por inserción directa -.
void insert_sort(longitud entera)
{
int insertNum
for(int I = 0; i & ltleni++)
{
insert num = lista[I]; //Elemento a insertar
int j = I;
while(j & gt;0 & amp& ampinsertNum & ltList[j-1]) //Encuentra la posición de inserción.
{
lista[j]= lista[j-1];
j-;
}
lista[j]= insertar número;
}
}
//2 ordenación de inserción binaria
void binario_insert_sort(int len)
{
int medio;
for(int I = 0; i & ltleni++)
{
int insert num = lista[I];
int izquierda = 0;
int derecha = I-1;
mientras(izquierda & lt ; = derecha) //Búsqueda binaria de la posición de inserción
{
Medio = (izquierda + derecha)/2;
if(insert num & gt; lista[medio])izquierda = medio+1;
else right = medio-1;
}
for(int j = I; j & gt izquierda;j-)lista[j]= lista[j-1];
lista[izquierda]= insertar número;
}
}
//3Ordenar por Hill-.
void shell_sort(int len)
{
int insertNum
int gap = len/2 //Incremento inicial< / p>
While (gap) //Cuando gap >;=1
{
for(int I = gap;i<lenI++) //Insertar y ordenar la secuencia espaciadora de espacios.
{
insert num = list[I]; //Elemento a insertar
int j = I;
while( j & gt; gap & amp& ampinsertNum & ltlist[j-gap])
{//Encontrar la posición de inserción
list[j]= list[j-gap];
j -=espacio;
}
lista[j]= insertar número; //Insertar
}
gap = gap/2; //Reducir el incremento
}
}
//4 Seleccionar directamente ordenar-.
void select_sort(int len)
{
int k;
for(int I = 0; i & ltleni++)
{
k = I;
for(int j = I+1; j & ltlenJ++) //Encontrar el elemento más pequeño
if(list[j]<list[k])k = j;
swap(i,k); //Coloca el elemento más pequeño en la posición I.
}
}
//5 Clasificación del montón-.
//Creación o ajuste de montón
void filterDown(entero actual, último entero)
{
int child = 2 * current+1; //child es la posición secundaria actual.
int temp = list[current]; //Almacenar temporalmente el nodo raíz del subárbol
while(child & lt;=last)//Determinar si es el último en finalizar .
{
if(child & lt;last& amp& amplist[child]& lt;list[child+1])child++;
//Dejar niño Señala al mayor de los dos niños.
if(temp & gt; = list[child])break; //Si el código clave de //temp es grande, no se ajustará.
De lo contrario //De lo contrario, el hijo más grande sube.
{
lista[actual]= lista[niño];
actual = niño
niño = 2 * niño+1;
}
}
list[current]=temp; //Coloca los elementos temporales en temp en la ubicación adecuada.
}
void heap_sort(int len)
{
for(int I =(len-2)/2; i & gt=0;i - ) filterDown(i, len-1);
//Crear un montón
for(I = len-1;i>0;i- )
{
swap(0, I);
filterDown(0, I-1); //Ajusta continuamente el montón al máximo.
}
}
//6 Clasificación de burbujas-.
void bubble_sort(longitud entera)
{
for(int I = 0; i & ltleni++)
for(int j = I+1; j & ltlenj++)
if(lista[I]& gt; lista[j]) swap(i, j);
}
//7 Clasificación por agitador-.
void shaker_sort(int len)
{
int i, izquierda = 0, derecha = len - 1, shift = 0;
while(left<right)
{
for(i =left;i<i++) //Ordena las burbujas a la derecha.
{
if(lista[I]& gt; lista[i+1])
{
intercambiar(i, I+1);
mayús = I;
}
}
Derecha = mayús;
for(i=right;i>left;i-)//Ordenar burbujas hacia la izquierda.
{
if(lista[I]& lt; lista[i-1])
{
intercambiar(i, I-1);
shift = I;
}
}
Izquierda = shift
}
}
//8 Clasificación rápida-.
void quick_sort(int izquierda, int derecha)
{
int i = izquierda
int j = derecha
int pivot = lista[izquierda];
mientras(i<j)
{
mientras(i< Johnson & Johnson. & amplist[ j]> ;= pivot)j-;//Encuentra el elemento que es menor que la base.
if(i<j) swap(i,j);
while(i<J&J&list[I]<=pivot)i++;// Encuentra elementos mayores que la base.
if (i<j) swap(i,j);
}
if (i!=izquierda) quick_sort(izquierda,I-1) ;/ /Ordenar lista [izquierda...i-1]
If (j!=right) quick_sort(j+1, right); //Ordenar lista [j+1...derecha]
}
//9 Orden de fusión: recursivo -.
//Método específico: utilice merge_link[] para proporcionar la función de lista vinculada. Merger_link[i] corresponde a la subsecuencia ordenada.
//El subíndice del nodo después de merge_list[i] en el merge_list[] original;
//merger_link[0] siempre indica el subíndice ordenado en merge_list[] El subíndice del nodo al comienzo de la secuencia;
//st1, st2 son los primeros nodos de las dos secuencias ordenadas;
//Fúndelos y devuelve su primer nodo El subíndice de, es decir, merge_link[0].
int list_merge(int st1, int st2)
{
int k = 0, i = st1, j = st2
Y (I&&J) //Cuando no se detecta ninguna secuencia.
if(merge_list[I]& lt; = merge_list[j]) // merge_list[i] y merge_list[j]
{//Los pequeños y medianos están conectados a merge_link [k]Después
merge_link[k]= I
k = I
I = merge_link[I]; ;
}En caso contrario
{
merge _ link[k]= j
k = j; p>j = merge_link[j];
}
If (!I)merge_link[k]= j; //El resto de merge_list no detectado[]
else merge_link[k]= I; //Después de conectarse a merge_link[k]
Devuelve merge_link[0];
}
int merge_sort(int izquierda, int derecha)
{
if(izquierda>=derecha) devuelve izquierda;
int medio =(izquierda +derecha)/2;
//Fusionar subsecuencias izquierda y derecha
Devuelve list_merge(merge_sort(izquierda, medio), merge_sort(centro+1, derecha));
}
//10 conteo sort
void counting_sort(int len, int max)
{
int result[ NUM] //Guardar temporalmente el resultado
int * mark = new int[max]; //Marcar elementos en la lista desordenada
memset(mark, 0, max * sizeof (int));
for(int I = 0;I & ltleni++)mark[list[I]]++;
//Calcular el número de apariciones de un elemento
for(I = 1;I<maxi++)mark[I]+= mark[I-1];
//Calcula la posición del elemento en la lista ordenada.
for(I = len-1;I>= 0;I-)
{
Resultado[marca[lista[I]]-1 ]= list[I]; // Lista [i] directamente a través de mark[].
Marcar [Lista[I]]-; //Almacenado en orden en el resultado []
}
Eliminar [] marca;
//Volcar a la lista para generar los resultados.
for(I = 0; I & ltleni++) lista[I] = resultado[I];
}
// - Proceso principal.
int main()
{
init();
int inp
mientras(verdadero)
{
cout & lt& lt"Por favor seleccione:";//Seleccione el método de clasificación
CIN & gt;& gtinp
Lista de inicialización (InP); //Inicializar lista desordenada
Cambiar (inp) //Clasificación variada
{
Caso 1: insertar _ sort( NUM ); break;
Caso dos: binario_insert_sort(NUM); break;
Caso tres: shell_sort(NUM);
Caso 4: seleccione _ sort(NUM); break;
Caso 5: montón _ sort(NUM);
Caso 6: bubble _ sort(NUM); p>Caso 7: shaker _ sort(NUM); Break;
Caso 8: quick_sort(0, NUM-1);
Situación 9: merge_sort(1, NUM); );
Caso 10: count_sort(NUM, MAX;
Caso 0: salida (0); p>
cout & lt& lt"Ordenar resultado:"
Si (inp!=9) out(list, 0, NUM);
En caso contrario{
int I = merge_link[0];
int j = 0;
Cuando(I)
{
j++ ;
cout & lt& ltmerge _ list[I]& lt;& lt" ";
I = fusionar _ link[I]
if( j % 18 = = 0)cout & lt;& ltendl
}
cout & lt& ltendl
}
}
Devuelve 0;
}
//Método auxiliar -.
//Interfaz de inicialización
void inicialización()
{
cout & lt& ltendl
cout & lt& lt"Diez algoritmos de clasificación comunes (orden ascendente)"
cout & lt& lt"-"& lt;& ltendl
cout & lt& lt"1. Ordenación por inserción directa"
cout & lt& lt"2. Ordenación por inserción binaria
cout & lt& lt"3. Ordenación Hill"
cout & lt& lt"4. "
cout & lt& lt"5.Clasificación en montón"
cout & lt& lt"6.Clasificación de burbujas"
cout & lt& lt"7 .Agitación ordenar"
cout & lt& lt"8.Clasificación rápida"
cout & lt& lt"9.Clasificar por combinación"
cout & lt& lt "10. Contar ordenar"
cout & lt& lt"0.Exit"
cout & lt& lt"-"& lt;& ltendl
}
//Inicializar lista desordenada
void init_list(int inp)
{
if (inp == 0) regresa
<; p>cout & lt& lt"Series a ordenar:"If (inp == 9) //Generar una lista desordenada para ordenar por fusión
{
for(int I = 1; i& lt= NUMi++)
{
merge _ list[I]= rand()% MAX;
p>
merge_link[I]= 0;
}
out(merge_list, 1, NUM;
}
{
for(int I = 0;i<NUMi++)list[I]= rand()% MAX ;
.out(list, 0, NUM);
}
}
//Resultados de salida
void out(entero resultado[], longitud entera, longitud entera)
{
for(int I = ST; i & ltST+len; i++)
{
cout & lt& ltresult[I]& lt;& lt" ";
if((I+1)% 18 = = 0)cout & lt & ltendl
}
cout & lt& ltendl
}
//Intercambiar lista[i] y lista[j]
void swap(int i, int j)
{
int temp = lista[I];
lista[I]= lista [j];
lista[j]= temp;
}