Introdução básica ao algoritmo e sua complexidade

Complexidade do algoritmo

algoritmo:

Definição: Algoritmos são etapas usadas para resolver uma série de problemas

public static int add(int a, int b){
    
    
	return a + b;
}

public static int sum(int n){
    
    
	int sum;
	for(int i=0;i<n;i++){
    
    
		sum += i;
	}
	return sun;
}

Use algoritmos diferentes para resolver o mesmo problema, a eficiência pode ser diferente

---

Como julgar a qualidade de um algoritmo

conceito:

1. Complexidade de tempo: estimar o número de vezes que a instrução é executada
2. Complexidade do espaço: estimar o espaço de armazenamento ocupado pelo algoritmo

Representação da complexidade:

Notação Big O : geralmente, big O é usado para descrever a complexidade do algoritmo, que representa a complexidade do algoritmo n

Ignore constantes, coeficientes, ordem inferior

• 9 >> O (1)

• 2n + 3 >> O (n)

• n ² + 2n + 3 >> O (n ² )
  ……
  Nota : a notação Big O é apenas um modelo de análise aproximada, é uma estimativa e pode nos ajudar a entender a eficiência de execução de um algoritmo em um curto espaço de tempo

• A ordem logarítmica geralmente omite a base

  • $lo{g}_{2}n$ =$lo{g}_{9}n$ *$lo{g}_{2}9$

Portanto, $lo{g}_{2}n$ e$lo{g}_{9}n$ é denominado$logn$

Complexidade comum

Número de execuções	a complexidade	Termo informal
12	O(1)	Ordem constante
2n + 3	Sobre)	Ordem linear
n 2 + 2n	O (n 2 )	Ordem quadrada
4 $lo{g}_{2}n$ + 6	O ( $logn$ )	Ordem logarítmica
n $lo{g}_{2}n$ +34	O (n $logn$ )	n $logn$ pedido
2n 3 + 3n 2 + 2	O (n 3 )	Ordem cúbica
2 n	O (2 n )	Ordem exponencial

• O (1) <O ( $logn$ ) <O (n) <O (n$logn$ ) <O (n²) <O (n³) <O (2ⁿ) <O (n!) <O (nⁿ)

Por exemplo: sequência de Fibonacci

• Algoritmo Um

/**
     * 斐波那契数列 0 1 1 2 3 5 8……
     * 求第n个费波纳希数列的值
     */
    private static int feb(int n) {
    
    
        if (n <= 2) {
    
    
            return n;
        }
        return feb(n - 1) + feb(n - 2);
    }

• Algoritmo 2

/**
     *               0 1 2 3 4 5 6 7
     * 费斐波那契数列 0 1 1 2 3 5 8 13……
     * 求第n个费波纳希数列的值
     */
    private static int feb2(int n) {
    
    
        if (n <= 1) return n;

        int first = 0, second = 1, sum;

        for (int i = 0; i < n - 1; i++) {
    
     //n=4
            sum = first + second; //first:0  second=1
            first = second;
            second = sum;
        }
        return second;
    }
}

Direção de otimização do algoritmo

• Use o mínimo de espaço de armazenamento possível
• Use o mínimo de etapas de execução possível.
  Nota: O espaço pode ser trocado por tempo e tempo para as condições apropriadas.