L'idea principale:tempo costante
* La ramificazione è veloce: L'operazione primaria in un'istruzione `if` sta valutando la condizione e decidere quale ramo eseguire. Questo è un processo molto rapido e deterministico che coinvolge un singolo confronto (o una serie di operazioni booleane che possono essere considerate limitate). I processori moderni sono altamente ottimizzati per la ramificazione condizionale.
* Indipendente dalla dimensione dell'input: La decisione di eseguire il blocco `if` o il blocco` else` (né se non esiste `else`) non dipende dalla dimensione dei dati di input elaborati dall'algoritmo circostante. Dipende solo dalla condizione stessa.
Perché O (1) può essere fuorviante (contesto conta!)
Mentre l'istruzione `if` stessa * è o (1), il * codice * all'interno del blocco` if` o `else` può avere una complessità temporale. Questo è cruciale. Considera questi scenari:
1. o (1) if-block:
`` `Python
Se x> 5:
y =10 # o (1) Assegnazione
z =x + y # o (1) aggiunta
altro:
y =20 # o (1) Assegnazione
`` `
In questo caso, l'istruzione `if` e il codice all'interno * entrambi i rami * sono O (1). La complessità complessiva di questo frammento è O (1).
2. o (n) if-block:
`` `Python
Se len (my_list)> 0:
per i in gamma (len (my_list)):# o (n) loop
stampa (my_list [i])
altro:
Stampa ("Elenco è vuoto") # O (1)
`` `
Qui, se la condizione è vera, esegui un ciclo che itera attraverso `my_list`, rendendo la complessità del ramo` if` o (n). Se la condizione è falsa, esegui il codice O (1). La complessità * peggiore * di questo intero blocco di codice è O (n), perché l'istruzione `if` potrebbe portare all'esecuzione del codice O (N).
3. o (n^2) if-blocc:
`` `Python
Se condizione:
per i in gamma (n):
per j in gamma (n):
# Qualche operazione O (1)
passaggio
altro:
# O (1) operazione
passaggio
`` `
In questo esempio, la complessità del tempo diventa O (n^2) a causa dei loop nidificati all'interno dell'affermazione `if`, anche se la valutazione della condizione` if` è ancora O (1).
in riassunto
* La logica di ramificazione dell'istruzione `if` è O (1).
* La complessità temporale complessiva del codice contenente l'istruzione `if` dipende interamente dalla complessità del codice * all'interno * I blocchi` if` e `else`. Il blocco con la massima complessità dominerà.
* Quando si analizza gli algoritmi, è necessario considerare lo scenario peggiore, che di solito coinvolge il blocco `if` con la massima complessità eseguita.
Pertanto, mentre puoi dire che l'istruzione `if` * stessa * richiede tempo costante, devi Analizzare il codice all'interno dei rami per determinare la complessità del tempo reale del blocco di codice contenente `if`. Concentrati sul termine dominante (il blocco di codice che richiederà il più lungo da eseguire man mano che la dimensione dell'input cresce).
Programmazione © www.354353.com