1. Conceitos Básicos de Algoritmos
Um algoritmo é uma descrição dos passos na resolução de um problema particular, que é uma sequência finita de instruções, cada uma das quais representa uma ou mais operações.
Características do algoritmo:
1. Finitude: Um algoritmo deve sempre terminar após a execução de etapas finitas, e cada etapa pode ser concluída em tempo finito.
2. Determinístico: Cada instrução no algoritmo deve ter um significado definido, e somente a mesma saída pode ser obtida para a mesma entrada.
3. Viabilidade: As operações descritas no algoritmo podem ser implementadas realizando um número limitado de operações básicas que foram implementadas.
4. Entradas: Um algoritmo tem zero ou mais entradas, que são retiradas de um conjunto específico de objetos.
5. Saída: Um algoritmo possui uma ou mais saídas, que são quantidades que possuem uma certa relação com a entrada.
O que um bom algoritmo alcança:
Correção: O algoritmo deve ser capaz de resolver corretamente o problema.
Legibilidade: Os algoritmos devem ser bem legíveis para ajudar as pessoas a entender.
Robustez: Quando dados ilegais são inseridos, o algoritmo pode reagir ou processar adequadamente sem produzir resultados de saída inexplicáveis.
Eficiência e baixos requisitos de armazenamento: Eficiência refere-se ao tempo que o algoritmo leva para executar e requisitos de armazenamento referem-se ao espaço máximo de armazenamento necessário durante a execução do algoritmo, ambos relacionados ao tamanho do problema.
2. Medidas de Eficiência Algorítmica
A eficiência do algoritmo é descrita pela complexidade do tempo e complexidade do espaço
2.1 Complexidade de tempo do algoritmo
A complexidade do tempo compara o tempo de execução dos programas?
Não, porque as diferenças de hardware podem levar a diferenças de tempo, um programa ruim pode ser executado em menos tempo no computador de hoje do que um bom programa em um computador de dez anos, então não é muito atemporal sem uma comparação Se for preciso, então é muito mais justo para nós comparar pelo número de vezes que a instrução é executada.
Em geral, o número de repetições das operações básicas no algoritmo é uma função f(n) do tamanho do problema n, e a medida de tempo do algoritmo é denotada como T(n)=O(f(n)), o que significa que com o tamanho do problema n A taxa de crescimento do tempo de execução do algoritmo é a mesma que a taxa de crescimento de f(n), que é chamada de complexidade de tempo assintótica do algoritmo, ou abreviadamente, complexidade de tempo.
Por exemplo: o parâmetro de entrada é n, o número de declarações é f(n), a complexidade é O(f(n)) e a função O() é uma função que remove os coeficientes de termos de alta e baixa ordem -termos do pedido
int count=0;
A complexidade de tempo é O(0)
int n=8, count=0;
for (int i=1; i<=n; i++){
count++;
}
A complexidade de tempo é O(n)
2.2 A complexidade espacial do algoritmo
A complexidade do espaço considera o tamanho do programa (arquivo executável)?
A complexidade do espaço é considerar o tamanho da memória ocupada pelo programa quando ele está em execução, não o tamanho do arquivo executável. No entanto, não é preciso calcular a memória ocupada pelo programa quando ele está em execução. Muitos fatores afetarão o uso real de memória do programa, como o alinhamento da memória do compilador, a implementação subjacente do contêiner da linguagem de programação, etc. ., o que afetará a sobrecarga de memória do programa. Portanto, a complexidade do espaço é estimar aproximadamente o tamanho do uso de memória do programa com antecedência.
A complexidade de espaço S(n) de um algoritmo é definida como o espaço de armazenamento consumido pelo algoritmo, que é uma função do tamanho do problema n. Denote-o como S(n)=O(g(n)).
int j = 0;
for (int i = 0; i < n; i++) {
j++;
}
No primeiro pedaço de código, podemos ver que com a mudança de n, o espaço de memória a ser aberto não muda com a mudança de n,
ou seja, a complexidade do espaço desse algoritmo é uma constante, então ela é expressa como grande O(1)
int* a = new int(n);
for (int i = 0; i < n; i++) {
a[i] = i;
}
Criamos um novo array. O tamanho desses dados é n.
Embora haja um loop for, nenhum novo espaço é alocado. Portanto, a complexidade do espaço desse código depende principalmente da primeira linha, que pode
aumentar com n. , o tamanho da memória aberta cresce linearmente, ou seja, O(n)