Classificação de algoritmo

Dez algoritmos de classificação comuns podem ser divididos em duas categorias:

Classificação comparativa : a ordem relativa dos elementos é determinada por comparação. Como sua complexidade de tempo não pode exceder O (nlogn), também é chamada de classificação de comparação de tempo não linear.
Classificação não comparativa : a ordem relativa dos elementos não é determinada por comparação. Ela pode romper o limite inferior de tempo com base na classificação comparativa e executar no tempo linear, por isso também é chamada de classificação não comparativa no tempo linear.

Complexidade do algoritmo

Conceitos relacionados

Estável : Se a estiver originalmente na frente de b e a = b, a ainda estará na frente de b após a classificação.
Instável : se a estiver originalmente na frente de b e a = b, a pode aparecer atrás de b após a classificação.
Complexidade de tempo : o número total de operações em dados classificados. Reflete a lei do número de operações quando n muda.
Complexidade do espaço: refere-se ao algoritmo no computador

Uma medida do espaço de armazenamento necessário para execução interna, que também é uma função do tamanho dos dados n.

1. Classificação por bolha (classificação por bolha)

A classificação por bolha é um algoritmo de classificação simples. Ele visitou repetidamente a sequência a ser classificada, comparando dois elementos por vez e trocando-os se estivessem na ordem errada. O trabalho de visitar a sequência é repetido até que não sejam necessárias mais trocas, o que significa que a sequência foi classificada. A origem do nome desse algoritmo é porque quanto menor o elemento irá lentamente "flutuar" para o topo da sequência através da troca.

1.1 Descrição do algoritmo

Compare os elementos adjacentes. Se o primeiro for maior que o segundo, troque os dois;
Faça o mesmo trabalho para cada par de elementos adjacentes, do primeiro par no início ao último par no final, de modo que o último elemento seja o maior número;
Repita as etapas acima para todos os elementos, exceto o último;
Repita as etapas 1 ~ 3 até que a classificação seja concluída.

1.2 Demonstração de animação

1.3 implementação de código

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int maxn = 100;
int arr[maxn], length;

//设置随机数组
void setRandArray(int a[]) {
	srand((unsigned)time(NULL));
	for (int i = 0; i < length; i++) {
		int j = rand() % 100;
		a[i] = j;
	}
}

//输出数组
void showArray(int* a) {
	cout << "数组元素内容：";
	for (int i = 0; i < length; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}

//冒泡排序
void bubbleSort(int *arr) {
	for (int i = 0; i < length - 1; i++) {
		for (int j = 0; j < length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

int main()
{
	cout << "输入元素个数：";
	cin >> length;
	setRandArray(arr);
	showArray(arr);
	bubbleSort(arr);
	cout << "冒泡排序后的数组：" << endl;
	showArray(arr);
	return 0;
}

2. Classificação por Seleção (Classificação por Seleção)

Seleção-ordenação (Seleção-ordenação) é um algoritmo de ordenação simples e intuitivo. Seu princípio de funcionamento: primeiro encontre o menor (grande) elemento na sequência não classificada, armazene-o no início da sequência classificada e, em seguida, continue a encontrar o menor (grande) elemento dos elementos não classificados restantes e, em seguida, coloque-o no seqüência ordenada No final. E assim por diante, até que todos os elementos sejam classificados.

2.1 Descrição do algoritmo

A seleção direta e a classificação de n registros podem ser diretamente selecionadas e classificadas n-1 vezes para obter um resultado ordenado. O algoritmo específico é descrito a seguir:

Estado inicial: a área desordenada é R [1..n], e a área ordenada está vazia;
No início da i-ésima classificação (i = 1,2,3 ... n-1), a área ordenada atual e a área desordenada são R [1..i-1] e R (i..n) respectivamente. Esta viagem de classificação seleciona o registro R [k] com a menor chave da área desordenada atual, e o troca com o primeiro registro R da área desordenada para fazer R [1..i] e R [i + 1 ..n ) Torne-se uma nova área ordenada com o número de registros aumentado em um e uma nova área desordenada com o número de registros diminuído em um;
No final da passagem n-1, a matriz é ordenada.

2.2 Demonstração de imagens em movimento

2.3 Implementação do código

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int maxn = 100;
int arr[maxn], length;

//设置随机数组
void setRandArray(int a[]) {
	srand((unsigned)time(NULL));
	for (int i = 0; i < length; i++) {
		int j = rand() % 100;
		a[i] = j;
	}
}

//输出数组
void showArray(int* a) {
	cout << "数组元素内容：";
	for (int i = 0; i < length; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}

//选择排序
void selectionSort(int arr[]) {
	int minIndex, temp;
	for (int i = 0; i < length - 1; i++) {
		minIndex = i;
		for (int j = i + 1; j < length; j++) {
			if (arr[j] < arr[minIndex]) {
				minIndex = j;
			}
		}
		temp = arr[i];
		arr[i] = arr[minIndex];
		arr[minIndex] = temp;
	}
}

int main()
{
	cout << "输入元素个数：";
	cin >> length;
	setRandArray(arr);
	showArray(arr);
	selectionSort(arr);
	showArray(arr);
	return 0;
}

3. Classificação por inserção (classificação por inserção)

A descrição do algoritmo de Insertion-Sort é um algoritmo de classificação simples e intuitivo. Seu princípio de funcionamento é construir uma sequência ordenada. Para dados não classificados, faça a varredura de trás para a frente na sequência classificada, encontre a posição correspondente e insira.

3.1 Descrição do algoritmo

De um modo geral, a classificação por inserção é implementada na matriz usando no local. O algoritmo específico é descrito a seguir:

A partir do primeiro elemento, pode-se considerar que o elemento foi classificado;
Retire o próximo elemento e faça a varredura de trás para a frente na sequência ordenada de elementos;
Se o elemento (classificado) for maior que o novo elemento, mova o elemento para a próxima posição;
Repita a etapa 3 até encontrar a posição onde o elemento classificado é menor ou igual ao novo elemento;
Após inserir o novo elemento nesta posição;
Repita as etapas 2 ~ 5.

3.2 Demonstração de imagens em movimento

3.2 Implementação do código

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int maxn = 100;

//设置随机数组
void setRandArray(int a[], int length) {
	srand((unsigned)time(NULL));
	for (int i = 0; i < length; i++) {
		int j = rand() % 100;
		a[i] = j;
	}
}

//输出数组
void showArray(int* a, int length) {
	cout << "数组元素内容：";
	for (int i = 0; i < length; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}

//插入排序
void insertionSort(int *arr,int len){
	int preIndex,current;
	for(int i = 1; i < len; i++){
		preIndex = i - 1;
		current = arr[i];
		while(preIndex >= 0 && arr[preIndex] > current){
			arr[preIndex + 1] = arr[preIndex];
			preIndex--;
		}
		arr[preIndex + 1] = current;
	}
} 

int main()
{
	int arr[maxn], length;
	cout << "数组元素个数：";
	cin >> length;
	setRandArray(arr,length);
	showArray(arr,length);
	insertionSort(arr,length);
	showArray(arr,length);
	return 0;
}

4. Classificação Hill (Classificação Shell)

Shell inventou em 1959, o primeiro algoritmo de classificação a quebrar O (n2), que é uma versão aprimorada da classificação por inserção simples. A diferença entre ele e a classificação por inserção é que ele comparará os elementos mais distantes primeiro. A classificação em colina também é chamada de classificação incremental reduzida .

4.1 Descrição do algoritmo

Primeiro divida toda a sequência de registros a serem classificados em várias subseqüências para classificação por inserção direta, a descrição do algoritmo específico:

Escolha uma sequência incremental t1, t2, ..., tk, onde ti> tj, tk = 1;
Ordene a sequência k vezes de acordo com o número de sequências de incremento k;
Em cada passagem de classificação, de acordo com o incremento correspondente ti, a seqüência a ser classificada é dividida em várias subseqüências de comprimento m, e cada subtabela é inserida e classificada diretamente. Quando apenas o fator de incremento é 1, toda a sequência é tratada como uma tabela, e o comprimento da tabela é o comprimento de toda a sequência.

Primeiro, ele divide o conjunto de dados maior em vários grupos (agrupados logicamente) e, em seguida, insere e classifica cada grupo separadamente. Nesse momento, a quantidade de dados usada pela classificação por inserção é relativamente pequena (cada grupo) e a eficiência de inserção relativamente alta