5 algoritmos de clasificación simples en lenguaje C

Este artículo presenta principalmente cinco algoritmos de clasificación simples y de uso común: clasificación por burbujas, clasificación rápida, clasificación por inserción, clasificación por selección, clasificación por colinas . Incluyendo sus ideas básicas y la implementación del código. Vale la pena mencionar que la complejidad de tiempo promedio de la clasificación por inserción, la clasificación de burbujas y la clasificación por selección es $O\izquierda ( n^{2} \derecha )$ , por lo que es mejor en el caso de datos menos ordenados ; mientras que la complejidad de tiempo promedio de la clasificación Hill y la clasificación rápida es $O\izquierda (nlogn\derecha)$ , por lo tanto, es mejor cuando hay una gran cantidad de datos de ordenación, pero para una ordenación rápida, no es bueno cuando los datos están básicamente en orden , lo cual se explicará en detalle a continuación. (dispuestos en orden ascendente)

1. Clasificación de burbujas

Idea básica:

La clasificación de burbujas es una clasificación muy bien entendida, como su nombre indica: burbujeo. En este momento, los datos que se ordenarán se organizan de arriba a abajo, y dos datos adyacentes se comparan comenzando desde el número superior (los primeros datos), los datos más pequeños flotan hacia arriba y los datos más grandes se hunden para lograr el efecto de clasificación.

(1) Compare cada par de elementos adyacentes. Si el primero es más grande que el segundo, cambie las posiciones de estos dos elementos y compárelos a su vez hasta el último par de datos. Esta es una ronda de operaciones.

(2) Repita n rondas de esta operación (n es el número de elementos), pero el último elemento después de cada ronda no necesita participar en la próxima ronda de comparación, porque después de una ronda de clasificación, el último elemento debe ser más que todos los elementos anteriores Ambos son grandes.

(3) Por lo tanto, los elementos que deben compararse en cada ronda se reducen hasta que no hay números para comparar. (Sin embargo, para reducir el número de comparaciones, puede registrar si hay intercambio de datos en cada ronda. Si no hay intercambio, significa que los datos actuales han sido fotografiados en orden de menor a mayor, y puede saltar fuera del bucle directamente)

Código:

#include<stdio.h>

int main() {
	int n, m, i, j, temp;
	int arr[100];

	scanf_s("%d", &n);    //scnaf_s是更为安全的输入方式；n为元素的个数；
	for (i = 0; i < n; i++) {
		scanf_s("%d", &arr[i]);    //输入数据；
	}

	m = n;            //因为每进行一次第一轮循环，需要排序的数据都要“--”，因此定义变量m=n；
	for (i = 0; i < n; i++) {
		int exchange = 0;           //记录这一轮会不会有数据的交换；
		for (j = 0; j < m-1; j++) {
			if (arr[j] > arr[j + 1]) {
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				exchange = 1;
			}
		}
		m--;
		if (!exchange)  //若没有数据的交换，则数据已经排列完毕，跳出循环；
			break;
	}
	for (i = 0; i < n; i++) {
		printf("%d ", arr[i]);        //输出
	}

	return 0;

}

2. Clasificación rápida (Quick Sort)

Quick sort es el algoritmo de clasificación con el mejor rendimiento promedio entre estas cinco categorías.Utiliza la idea de divide y vencerás y llama funciones recursivas , por lo que también es la más difícil de estas cinco categorías.

Idea básica:

El punto clave de la ordenación rápida es encontrar un valor de referencia y dividir la secuencia en dos partes: las que son mayores que el valor de referencia se colocan a la derecha y las que son más pequeñas que el valor de referencia se colocan a la izquierda. . Luego repite la operación sobre estas dos partes respectivamente, una se divide en dos, y la otra se divide en cuatro... hasta que cada elemento se convierte en su propia parte.

1. Establezca el elemento central de los datos como el valor de referencia, inicialice el comando para $i$ señalar el elemento más a la izquierda y el comando para $j$ señalar el elemento más a la derecha, $yo ++$ busque un número mayor que el número de referencia de izquierda a derecha y $j--$ encuentre un número más pequeño que el número de referencia de derecha a izquierda, intercambie las posiciones de los dos números hasta que $yo=j$ .

2. Tal subdivisión continua y recursividad logran el propósito de ordenar

Código:

#include<stdio.h>

void Quicksort(int a[], int left, int right) {   //快排函数
	int temp;
	int mid = a[(left + right) / 2];            //找基准值
	int i = left;
	int j = right;
//在左侧找一个大于基准值的数，在右侧找一个小于基准数的数，然后交换位置
	while (i <= j) {   
		while (a[i] < mid) i++;
		while (a[j] > mid) j--;
		if (i <= j) {
			temp = a[i];
			a[i] = a[j];
			a[j] = temp;
			i++;
			j--;
		}
	}
	if (i < right) Quicksort(a, i, right);        //递归
	if (j > left) Quicksort(a, left, j);           //递归
}

int main() {
	int n, m, i;
	int arr[100];
	scanf_s("%d", &n);
	for (i = 0; i < n; i++) {
		scanf_s("%d", &arr[i]);						//输入
	}

	Quicksort(arr, 0, n - 1);                        //调用函数

	for (i = 0; i < n; i++) {
		printf("%d ", arr[i]);						//输出
	}
	return 0;
}

3. Clasificación por inserción

Idea básica:

Divida los datos en dos grupos: un grupo está ordenado y el otro grupo no está ordenado , y los elementos de los datos no ordenados se insertan a su vez en los datos ordenados, de modo que todos los datos se ordenen (la agrupación aquí es subconsciente , y en realidad no usa dos matrices para dividir)

1. Inicialmente, el primer elemento se divide en grupos ordenados (porque solo hay un elemento, por lo que se considera ordenado), y el resto de elementos se dividen en grupos desordenados.

2. Entonces, solo necesita comenzar desde el segundo elemento, encontrar su posición en el grupo ordenado e insertarlo hasta el último elemento.

3. Pero esto no significa que solo se necesite un bucle, porque en el proceso de "encontrar su propia posición", debe compararse con el elemento anterior, si es más pequeño, mueva ese elemento hacia atrás, si es más grande, se inserta en la posición de la última comparación

Código:

#include<stdio.h>

int main() {
	int n, m, i, j, temp;
	int arr[100];

	scanf_s("%d", &n);
	for (i = 0; i < n; i++) {
		scanf_s("%d", &arr[i]);						//输入 
	}
    for(i=1; i<n; i++)								//从无序组的第一个元素开始 
        if(arr[i] < arr[i-1])   						// 判断是否要向前寻找插入的位置 
        {
            int temp = arr[i];                       
            for(j=i-1; j>=0 && arr[j]>temp; j--)    //将大于自己的数依次向后挪位 
                arr[j+1] = arr[j];                    
            arr[j+1] = temp;                       //插入 
        }
	for (i = 0; i < n; i++) {
		printf("%d ", arr[i]);						//输出 
	}
	return 0;
}

4. Clasificación de selección simple

Idea básica:

Suponga que un conjunto de datos tiene n elementos, seleccione el más pequeño de los n elementos para intercambiar posiciones con el primer elemento y luego seleccione el más pequeño entre los n-1 elementos restantes para intercambiar posiciones con el segundo elemento hasta que Seleccione el más pequeño de los dos últimos elementos y colóquelo en la penúltima posición, y la clasificación está completa.

#include<stdio.h>

int main() {
	int n, m, i, j, p, temp;
	int arr[100];

	scanf_s("%d", &n);
	for (i = 0; i < n; i++) {
		scanf_s("%d", &arr[i]);						//输入 
	}

	for (i = 0; i < n - 1; i++) {
		p = i;                            //p用于记录最小元素的下标
		for (j = i + 1; j < n; j++) {       //找到剩下元素中最小的那一个
			if (arr[p] > arr[j])
				p = j;
		}
		temp = arr[i];                        //temp是交换两数时的中间变量
		arr[i] = arr[p];
		arr[p] = temp;
	}
	for (i = 0; i < n; i++) {
		printf("%d ", arr[i]);						//输出 
	}
	return 0;
}

Código:

5. Clasificación de conchas (Clasificación de conchas)

La clasificación por colinas es una optimización de la clasificación por inserción . Primero clasifica previamente la secuencia que se va a clasificar y luego realiza una clasificación por inserción en la subsecuencia. La diferencia es que la complejidad temporal de la clasificación por inserción después del preprocesamiento es $O\izquierda ( n \derecha )$

Idea básica:

Defina un espacio de intervalo. En un conjunto de datos, tome los elementos separados por espacios como un grupo, realice una clasificación de inserción simple en los elementos del grupo y luego continúe reduciendo el espacio y repita esta operación para completar el preprocesamiento del datos hasta la brecha = 1. Indica que todos los números se insertan y ordenan, y el algoritmo termina.

1. Inicialice $espacio=\frac{n}{2}$ (n es el número de elementos), agrupe todos los elementos con una distancia de separación en los datos en un grupo (en este momento, este grupo de datos se dividirá en grupos, cada grupo tiene dos elementos y $\frac{n}{2}$ cada el grupo está ordenado)

2. Luego reduzca la brecha para $\frac{n}{4}$ agrupar todos los elementos con una distancia de brecha en los datos en un grupo (en este momento, este grupo de datos se dividirá en $\frac{n}{4}$ grupos, cada grupo tiene cuatro elementos y cada grupo está ordenado)

3. Repita hasta que gap = 1. En este momento, los datos son un grupo con n elementos, y una ordenación por inserción simple es suficiente.

Código:

#include<stdio.h>

int main() {
	int n, m, i, j, temp,gap;
	int arr[100];

	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		scanf("%d", &arr[i]);						//输入
	}

    for(gap=n/2; gap>0; gap/=2)
        for(i=gap; i<n; i++)
            for(j=i-gap; j>=0 && arr[j]>arr[j+gap]; j-=gap){
            	temp=arr[j];
            	arr[j]=arr[j+gap];
            	arr[j+gap]=temp;
			}
	for (i = 0; i < n; i++) {
		printf("%d ", arr[i]);						//输出
	}
	return 0;
}

un breve ensayo