Proporcione el código del programa en lenguaje C
=========================================== ======
Función: Clasificación selectiva
Entrada: el nombre de la matriz (también la primera dirección de la matriz), el número de elementos en la matriz
================== ============================ ===
*/
/*
======================= ==== ==========================
Una breve descripción de la idea del algoritmo:
En el orden a ordenar Del conjunto de números, seleccione el más pequeño e intercámbielo con el número clasificado en primer lugar;
Luego busque el más pequeño entre los números restantes e intercámbielo con el número clasificado los segundos dígitos se intercambian, y así sucesivamente
hasta que se compara el penúltimo dígito con el último dígito.
La clasificación de selección es inestable. Complejidad del algoritmo O(n2) - [n al cuadrado]
================================= =======================
*/
void select_sort(int *x, int n)
{<
int i, j, min, t;
for (i=0; ilt; n-1; i) /* Número de selecciones : 0~n-2***n-1 veces**/
{
min = i; /*Supongamos que el número actualmente subíndice i es el más pequeño, y luego proceda después de la comparación Ajustar*
for (j=i 1; jlt; n; j)/* Bucle para descubrir qué subíndice es el número más pequeño*/
{
if (*(x j) lt; *(x min))
{
min = j /* Si el siguiente número es menor que el número anterior; , escribe su Subíndice*/
}
}
}
}
si (min != i) /* Si min cambia en el bucle, intercambia datos */
{
t = *(x i);
*(x i) = * (x min);
*(x min) = t;
}
}
p>===== = ============================================
Función: ordenación por inserción directa
Entrada: nombre de la matriz (también conocida como la primera dirección de la matriz), el número de elementos en la matriz
======= ======= ============ =======================
* /
>*
================================== ======= ============
Una breve descripción de la idea del algoritmo:
En el conjunto de números a ordenar, supongamos que el primero (o segundo) es el mismo que el primero (o tercero). Números, suponiendo que los primeros (n-1) [ngt;=2] números se hayan ordenado bien
, ahora necesitamos insertar el n-ésimo número en los números previamente ordenados, de modo que estos n los números
p>
también se ordenarán bien.
Y así sucesivamente hasta que todos los números estén alineados.
La clasificación por inserción directa es estable. Complejidad del tiempo del algoritmo O(n2) - [n al cuadrado]
================================ = =======================
*/
void insert_sort(int *x, int n)
{
int i, j, t;
for (i=1; ilt; n; i) /* Número de selecciones: 1~n -1 ***n-1 veces**/
{
/*
Ordena temporalmente los números con el subíndice i. Nota: La razón por la que los subíndices comienzan desde 1 es que al principio
el primer número, el número con subíndice 0, no está precedido por ningún número y es independiente, por lo que se considera
está en orden.
*/
t=*(xi);
para (j=i-1; jgt;=0 amp; amp; tlt;*( x j); j--)/*Nota: j=i-1, j--, aquí está el número con el subíndice i, que está precedido por una secuencia utilizada para encontrar la posición de inserción. */
{
*(x j 1) = *(x j); /* Si se cumple la condición, retrocede. El peor de los casos es que t es menor que cualquier número con subíndice 0, irá a la parte superior, j==-1, y saldrá del bucle*/
}
* (x j 1) = t; /*Encuentra la posición del número con subíndice i*/
}
}
/*
== =============== ================================
Función: clasificación por burbujas
Entrada: nombre de la matriz (también conocida como la primera dirección de la matriz), el número de elementos de la matriz
== ======== ===================================== ==
*/
/*
============================== =========== ===============
Breve descripción de la idea del algoritmo:
En un conjunto de números a ordenar, para todos los números actualmente sin ordenar en el número de rango. Compare y ajuste los dos números adyacentes arriba y abajo en secuencia, de modo que el número mayor se hunda y el más pequeño emerja. Es decir, siempre que se comparen dos números adyacentes y se encuentre que su orden es opuesto al orden requerido, se invertirán.
El siguiente es un algoritmo de burbujeo mejorado, que registra la
posición k del último número de hundimiento después de cada escaneo, reduciendo así el número de escaneos del bucle externo.
La clasificación de burbujas es estable.
Complejidad del tiempo del algoritmo O(n2) - [n al cuadrado]
================================ = ========================
*/
void bubble_sort(int *x, int n )
{
int j, k, h, t
for (h=n-1; hgt; 0; h=k) /* bucle Hasta que no haya rango de comparación*
{
for (j=0, k=0; jlt; h; j) /* Preestablece k=0 cada vez y escanea un bucle Actualizar k* más tarde
{
if (*(x j) gt; *(x j 1)) /* El grande viene al final, el pequeño viene primero*/
{
t = *(x j);
*(x j) = *(x j 1); 1) = t ; /*Intercambio completo*/
k = j; /*Guardar la última posición de hundimiento. De esta manera, todo lo que esté después de k quedará ordenado y ordenado. */
}
}
}
}
/*
=================================================
Función: Hill sort
Entrada: nombre de la matriz (también llamado la primera dirección de la matriz), el número de elementos en la matriz
===== === =========================================
*/
/*
================================= ====== = ================
Breve descripción de la idea del algoritmo:
En el algoritmo de clasificación por inserción directa , cada vez que se inserta un número, solo Agregar un nodo a una secuencia ordenada
no hace nada para insertar el siguiente número.
Si comparar números que están muy separados (llamado
incremento) puede mover el número entre múltiples elementos, entonces una sola comparación puede eliminar
El intercambio de múltiples elementos .
D.L. Shell implementó esta idea en 1959 en el algoritmo de clasificación que lleva su nombre. El algoritmo primero divide un conjunto de números que se ordenarán en varios grupos de acuerdo con un cierto incremento d, y los subíndices registrados en cada grupo difieren en d. Todos los elementos de cada grupo se ordenan, luego se les aplica un incremento menor y la clasificación se realiza nuevamente en cada grupo. Cuando el incremento disminuye a 1, el número completo a ordenar se agrupa en un grupo y se completa la clasificación.
La siguiente función es una implementación del algoritmo de clasificación Hill, que primero incrementa la mitad de la secuencia,
luego la reduce a la mitad cada vez hasta que el incremento es 1.
============================================ === ==========
*/
void shell_sort(int *x, int n)
{
int h, j, k, t;
for (h=n/2; hgt; 0; h=h/2) /* Incremento de control*/
{
for (j=h; jlt; n; j) /* Este es en realidad el tipo de inserción directa anterior*/
{
t = * (x j);
for (k=j-h; (kgt;=0 amp;amp; tlt;*(x k)); k-=h)
{
*(x k h) = *(x k
}
*(x k h) = t; p > }
}
}
/*
================ = ================================
Función: Clasificación rápida
Entrada: nombre de la matriz (es decir, la primera dirección de la matriz), los subíndices del elemento inicial y del elemento final de la matriz
=============== ====== == ==========================
*/
/*
========================================== ======= =====
Breve descripción de la idea del algoritmo:
La clasificación rápida es una mejora importante de la clasificación de burbujas. La idea básica es que después de un único escaneo, la longitud de la secuencia ordenada se puede reducir significativamente. En la clasificación de burbujas, un único escaneo
solo puede garantizar que el número más grande se mueva a la posición correcta, y la longitud de la secuencia ordenada solo puede reducirse en
1. La clasificación rápida garantiza que en un escaneo, los números a la izquierda de un número determinado (suponiendo que sea un punto de referencia) sean más pequeños que él, y los números a la derecha del número sean más grandes que él. Luego procese los números en los lados izquierdo y derecho de la misma manera hasta que solo haya un elemento en los lados izquierdo y derecho del punto de referencia. Fue propuesto en 1962 por C.A.R.
Obviamente, la clasificación rápida se puede implementar de forma recursiva y, por supuesto, también se puede implementar mediante el análisis recursivo apilado.
La siguiente función está implementada de forma recursiva, y aquellos que estén interesados pueden cambiarla a una forma no recursiva.
Quicksort es inestable. La complejidad temporal del algoritmo es O(nlog2n) en el mejor de los casos y O(n2) en el peor de los casos
==================== = =================================
*/
void quick_sort(int *x, int bajo, int alto)
{
int i, j, t
if (bajo lt; alto) / * El índice inicial y final de los elementos a ordenar, asegurando que el elemento más pequeño se coloque a la izquierda y el elemento más grande a la derecha.
Aquí, el elemento con subíndice bajo es la base*
{
i = bajo
j = alto
t =; *(x low); /*Número base almacenado temporalmente**
while (ilt; j) /*Escaneo en bucle**
{
while ( ilt; j amp; amp; *(x j)gt; t) /* A la derecha, siempre que sea mayor que el punto de referencia, todavía se coloca a la derecha */
{
j--; /* Avanzar una posición*/
}
if (ilt; j)
{
*(x i) = *(x j); /* El bucle anterior sale: es decir, aparece un número menor que la base, reemplaza el número base*/
/* Mover una posición; hacia atrás y use esto como base*/
}
while (ilt; j amp; amp; *(x i)lt; =t) /* A la izquierda, como siempre que sea menor o igual que el punto de referencia, todavía se coloca a la izquierda */
{
/* Mover una posición hacia atrás*/
}
if (ilt; j)
{
*(x j) = *(x i); es decir, el número que aparece es mayor que el número base que se coloca a la derecha*/
j-- /* Avanzar una posición*/
}
}
*(x i) = t; /* Después de escanear una vez, colóquelo a la derecha */
quick_sort(x, low, i-1); * Realice otra clasificación rápida de los números a la izquierda de los datos**
quick_sort(x, i 1, high /* Realice otra clasificación rápida de los números a la derecha de los datos* /
}
}
/*
================= =============================== =
Función: clasificación de montón
Entrada: nombre de la matriz (es decir, la primera dirección de la matriz), el número de elementos en la matriz
======== ============= ============================
*/
/*
============================== ==== ============= =====
Breve descripción de la idea del algoritmo:
La clasificación en montón es una clasificación por selección de árbol, que es una mejora directa y efectiva a la clasificación por selección.
La definición de montón es la siguiente: si y sólo si
satisface (higt; =h2i, higt; =2i 1) o (hilt; =h2i, hilt; =2i 1) (Cuando i=1, 2,...,n/2), la secuencia compuesta de n elementos (h1, h2,..., hn) se llama montón. Aquí sólo se analizan los montones que cumplen la condición anterior.
Como se puede ver en la definición de un montón, el elemento superior del montón (es decir, el primer elemento) debe ser el elemento más grande. Un árbol binario completo puede
representar la estructura del montón de forma muy intuitiva. La parte superior del montón es la raíz y los demás son los subárboles izquierdo y derecho.
Inicialmente, la secuencia de números que deben ordenarse se considera como un árbol binario almacenado secuencialmente, y luego se ajusta su orden de almacenamiento,
para convertirlo en un montón, con el El nodo raíz del montón tiene el número más grande.
Luego intercambie el nodo raíz con el último nodo del montón
. Luego, vuelva a escalar los números anteriores (n-1) en un montón. Y así sucesivamente hasta que solo haya dos nodos en el montón
, luego intercámbielos y finalmente obtenga una secuencia ordenada compuesta por n nodos.
A juzgar por la descripción del algoritmo, la clasificación del montón requiere dos procesos, uno es establecer el montón y el otro es intercambiar la posición entre la parte superior del montón y el último elemento del montón
. Por lo tanto, la clasificación del montón tiene dos funciones que forman el montón. Una es una función de penetración que construye el montón y la otra es una función que llama repetidamente a la función de penetración
para implementar la clasificación.
La clasificación del montón es inestable. La complejidad temporal del algoritmo es O (nlog2n).
*/
/*
Función: penetración para crear un montón
Entrada: nombre de la matriz (es decir, la dirección del primer dirección de la matriz), el número de elementos involucrados en la construcción del montón y desde qué elemento comenzar
*/
void sift(int *x, int n, int s)
{
int t, k, j;
t = *(x s); /* Filtrar elemento inicial*/
k = s; /* Subíndice del elemento inicial */
j = 2*k 1 /* Subíndice del elemento del subárbol derecho*/
while (jlt; n)
{
if (jlt; n-1 amp; amp; *(x j) lt; *(x j 1))/* Determine si se cumplen las condiciones del montón: si se cumplen, continúe con la siguiente ronda de comparación; de lo contrario, realice ajustes. */
{
j ;
}
si (tlt; *(x j))/* ajustar */
{
*(x k) = *(x j);
k = j /* Ajuste, el elemento inicial también se ajusta*/
j = 2*k 1; <
}
else /* No se necesitan más ajustes, ya es un montón, sal del bucle.
*/
{
descanso
}
}
*(x k) = t; * Iniciar el elemento para que esté en la posición correcta*/
}
/*
Función: Ordenación del montón
Entrada : Matriz de nombre (también llamada la primera dirección de la matriz), el número de elementos en la matriz
*/
void heap_sort(int *x, int n)
{
int i, k, t;
int *p;
para (i=n/2-1; igt; =0; i-- )
{
tamizar (x, n, i); /* inicializar montón**
}
for (k= n-1; kgt;=1; k--)
{
t = *(x 0); **
*(x 0) = *(x k);
*(x k) = t
tamizar(x, k, 0);
}
void main()
{
#define MAX 4
int *p, i , a[MAX];
/* Ingrese datos de prueba*/
p = a
printf("Ingrese d número para ordenar:\n" , MAX);
for (i=0; ilt; MAX; i)
{
scanf("d", p);
}
printf("\n");
/* Clasificación de selección de prueba***
p =
select_sort(p, MAX);
/**/
/* Prueba de clasificación por inserción directa***
/*
p = a;
insert _sort(p, MAX);
*/
/* Prueba de clasificación de burbujas***
/*
p = a
insert_sort(p, MAX
*/
/*Prueba rápida); ordenar**/
/*
p = a
quick_sort(p, 0, MAX-1
*); /
/*Probar clasificación del montón**/
/*
p =
heap_sort(p, MAX);
*/
for (p=a, i=0; i lt; MAX; i)
{
printf( "d ", *p)
}
printf("\n");
sistema("pausa"); p>}