Classificação de troca de algoritmo de classificação (classificação por bolha e classificação rápida)

Troca de ordenação: troca as posições de dois registros na sequência de acordo com o resultado da comparação das palavras-chave dos dois elementos da sequência.

Tipo de bolha

O princípio é o seguinte

Compare os elementos adjacentes. Se o primeiro for maior que o segundo, troque os dois.
Faça o mesmo para cada par de elementos adjacentes, desde o primeiro par no início até o último par no final. Neste ponto, o último elemento deve ser o maior número.
Repita as etapas acima para todos os elementos, exceto o último.

Continue a repetir as etapas acima para cada vez menos elementos até que não haja nenhum par de números para comparar.

A complexidade do tempo é melhor o (n) pior o (n2)

Complexidade do espaço o (1)

Implementação de 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;
}

Ordenação rápida

Separe os registros a serem classificados em duas partes independentes, classificando, e as palavras-chave de alguns dos registros são menores do que as palavras-chave da outra parte, e então as duas partes dos registros podem ser classificadas separadamente para obter a ordem de toda a sequência .
Implementação do 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;
}

Insira a descrição da imagem aqui

Complexidade de tempo O (n * número de camadas recursivas) Complexidade de espaço O (número de camadas recursivas)

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

Idéias otimizadas Ao selecionar o elemento do eixo de base, escolha as três comparações entre a cabeça, o meio e a cauda, ou escolha um número aleatório como o eixo de base