Cómo ordenar una línea completa de números de mayor a menor en lenguaje C
========================================== === =======
Función: clasificación selectiva
Entrada: nombre de la matriz (es decir, la primera dirección de la matriz), el número de elementos de la matriz
==================== ======================== =====
*/
/*
===================== ====== ==========================
Una descripción simple de la idea del algoritmo: entre un conjunto de números a ordenar, seleccione el número más pequeño y el primer número. En un conjunto de números a ordenar, seleccione el número más pequeño e intercámbielo con el número clasificado en primer lugar;
Luego encuentre el número más pequeño entre los números restantes e intercámbielo con el número clasificado en segundo lugar Los dígitos del se intercambian los dígitos, y así sucesivamente
hasta que se compara el penúltimo dígito con el último. El orden 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; i { min = i; /*Supongamos que el subíndice actual de i es el número más pequeño y ajústelo después. comparación*/ for (j=i+1; j { if (* (x+j) < *(x+min)) { min = j /* Si el siguiente número es menor que el anterior; número, escribe su subíndice */ } } } if (min != i) /* if min cambia en el bucle, luego intercambia datos*/ { t = *(x+i); *(x+i) = *(x +min) ; *(x+min) = t; } } } p> ================================================ = Función: clasificació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 un conjunto de números para ser ordenados, supongamos que los números anteriores (n-1) [n> =2] se han ordenado en orden Ahora inserte el enésimo número en el número ordenado anterior para que estos n números también están ordenados. Y así sucesivamente hasta que todos los números estén en orden. 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; i { /* Ordena temporalmente los números con el subíndice i. Nota: La razón por la que el subíndice comienza desde 1 es que al principio el primer número, es decir, el número con subíndice 0, no tiene ningún número delante y existe solo, por lo que se considera Está ordenado en orden. */ t=*(x+i); for (j=i-1; j>=0 && t<*(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 un subíndice de 0, luego muévase a la parte superior, j==-1, y salga 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 conocido 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 un conjunto de números para ordenar , desde arriba hacia abajo hasta los dos números adyacentes correspondientes, compare y ajuste secuencialmente todos los números actualmente sin ordenar en el rango. Se comparan y ajustan dos números adyacentes en secuencia, haciendo que el número mayor baje y el menor aumente. Es decir, siempre que se comparan dos números adyacentes y se encuentra que están en el orden opuesto al deseado, se invierten. El siguiente es un algoritmo de clasificación de burbujas 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; h>0; h=k) /* Bucle hasta que no haya rango de comparación * { for (j=0, k=0; j { if (* (x+j) > *(x+j+1)) /* El grande está atrás, el pequeño está adelante* { t = *(x+j); *(x+j) = *(x+j+1); *(x+j+ 1) = t; /*Intercambio completo*} /* =============== ========= ========================= Función: clasificación de montón Entrada: nombre de la matriz (también conocido como la primera dirección de la matriz), el número de elementos en la matriz ============= ======== =============== =============== */ /* ========== ==================================== ======= Algoritmo Breve explicación de la idea: la clasificación en montón es una clasificación por selección de árbol, que es una mejora efectiva en la clasificación por selección directa. La definición de montón es la siguiente: una secuencia de n elementos (h1, h2,..., hn), si y sólo si satisface (hi>=h2i ,hi >=2i+1) o (hi<=h2i,hi<=2i+1) (i=1,2,... ,n/2) Se llama montón. Aquí sólo se analizan los montones que cumplen la condición anterior. Según la definición de 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 queden 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 construir un montón y el otro es intercambiar las posiciones de la parte superior del montón y el último elemento del montón . Por lo tanto, la clasificación del montón consta de dos funciones. 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 primera 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; /* Índice del elemento del subárbol derecho*/ while (j { if (j { j++; } if (t<*(x+j))/*Ajustar** { *(x+k) = *(x+j); k = j /*El ajuste se completa y el elemento inicial se ajusta en consecuencia** j = 2*k + 1; } else /* No se necesitan más ajustes, ya es un montón, sal del bucle. */ { descanso; } } *(x+k) = t ; /*Coloca los elementos en la posición correcta* } /* Función: Ordenación del montón Entrada: nombre de la matriz; (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; i>=0; i--) { sift(x,n,i) ; /* Inicializar montón*/ } for (k=n-1; k >=1; k--) { t = *(x+0); /* desde la parte superior del montón hasta el último*/ *( 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; i { scanf("%d",p++); } printf("\n"); /* Prueba de clasificación de selección** p = a; select_sort(p,MAX); /**/ /*Prueba de ordenación por inserción directa** /* p = a; insert_sort(p,MAX) ; */ /*Probar clasificación de burbujas** /* p = a; insert_sort(p,MAX) ; */ /*Prueba de clasificación rápida** /* p = a; quick_sort(p,0,MAX-1); */ /*Probar clasificación del montón/* p = a; heap_sort(p,MAX); */ for ( p=a, i=0; i { printf("%d ",*p++); } printf("\n "); sistema("pausa"); }