Orden de intercambio de algoritmos de clasificación (clasificación de burbujas y clasificación rápida)

Swap sort: intercambia las posiciones de dos registros en la secuencia según el resultado de la comparación de las palabras clave de los dos elementos de la secuencia.

Ordenamiento de burbuja

El principio es el siguiente

Compare los elementos adyacentes. Si el primero es más grande que el segundo, cámbielos por dos.
Haga lo mismo para cada par de elementos adyacentes, desde el primer par al principio hasta el último par al final. En este punto, el último elemento debería ser el número más grande.
Repita los pasos anteriores para todos los elementos excepto el último.

Continúe repitiendo los pasos anteriores para cada vez menos elementos hasta que no haya un par de números para comparar.

La complejidad del tiempo es mejor o (n) peor o (n2)

Complejidad espacial o (1)

Implementación del código (c)

#include <stdio.h>
#include <stdbool.h>

void BubbleSort (int a[],int n){
      
        //冒泡排序 
	int i,j,temp;         
	for( i=0;i<n-1;i++){
      
      
		bool flag=false;      //表示本趟冒泡是否发生交换的标志 
		for( j=n-1;j>1;j--)   //一趟冒泡的过程 
		if(a[j-1]>a[j]){
      
            //后面的数小于前面的 进行交换 
			temp=a[j];
			a[j]=a[j-1];
			a[j-1]=temp;
			flag=true;    
		}
		if(flag==false)    //本趟遍历没有发生交换说明结束 
		return;
	}
}
void Printarr(int a[],int n)    //输出数组 
{
      
      
	int i;
	for(i=0;i<n;i++){
      
      
		printf("%d",a[i]);
	}
	return;
} 

int main(){
      
                      //主函数 
	int b,c;
	int a[]={
      
      1,8,7,5,6};
	int n=5;
	printf("未排序的数\n"); 
	Printarr(a,n);
	printf("\n");
	BubbleSort(a,n);
	printf("冒泡排好序的数\n");
	Printarr(a,n);
	return 0;
}

Ordenación rápida

Separe los registros que se clasificarán en dos partes independientes clasificándolos, y las palabras clave de algunos de los registros serán más pequeñas que las palabras clave de la otra parte, y luego las dos partes de los registros se podrán clasificar por separado para lograr el orden de toda la secuencia. .
Implementación del código c

#include <stdio.h>
#include <stdlib.h>

int getStandard(int array[], int i, int j) {
    
    
	//基准数据 
	int key = array[i];
	while (i < j) {
    
     	//因为默认基准是从左边开始，所以从右边开始比较 //当队尾的元素大于等于基准数据 时,就一直向前挪动 j 指针 
			while (i < j && array[j] >= key) {
    
    
				j--;
			}
			if (i < j) {
    
    
				array[i] = array[j];//当找到比 array[i] 小的时，就把后面的值 array[j] 赋给它
			}	
			while (i < j && array[i] <= key) {
    
    //当队首元素小于等于基准数据 时,就一直向后挪动 i 指针 
				i++;
			}
			//当找到比 array[j] 大的时，就把前面的值 array[i] 赋给它
			if (i < j) {
    
    
				array[j] = array[i];
			}
		}
	array[i] = key;//跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置
	return i;//把基准数据赋给正确位置 
}
void QuickSort(int array[], int low, int high) {
    
    
	//开始默认基准为 low
	if (low < high) {
    
    
		//分段位置下标 
		int standard = getStandard(array, low, high);
		//递归调用排序
		//左边排序 
		QuickSort(array, low, standard - 1);
		//右边排序 
		QuickSort(array, standard + 1, high);
	}
}

void display(int array[], int size) {
    
    
	int i;
	for (i = 0; i < size; i++) {
    
    
		printf("%d ", array[i]);
	}
	printf("\n");
}

int main() {
    
    
	int array[] = {
    
     49,38,65,97,76,13,27,49,10 };
	int size = sizeof(array) / sizeof(int);
	QuickSort(array, 0, size - 1);
	printf("排好的顺序为") ; 
	display(array, size);
    return 0;
}

Inserte la descripción de la imagen aquí

Complejidad temporal O (n * número de capas recursivas) Complejidad espacial O (número de capas recursivas)

Número mínimo de capas (log2n) máximo n

Ideas optimizadas Al seleccionar el elemento del eje base, elija las tres comparaciones entre la cabeza, el medio y la cola, o elija un número aleatorio como eje base