Ecco una rottura:
* Inserimento alla fine (usando `push_back` o equivalente): Questo è generalmente o (1) - tempo costante ammortizzato . "Amorted" significa che mentre occasionalmente il vettore deve riallocare la sua memoria sottostante (che richiede tempo (n)), il più delle volte l'inserimento sta semplicemente posizionando l'elemento nello slot disponibile successivo. In molti inserzioni, il tempo medio è vicino alla costante.
* Inserimento in una posizione specifica (usando `insert (posizione iteratore, valore)` o equivalente): Questo è o (n) - tempo lineare . Ecco perché:
1. Trovare la posizione: Se l'iteratore viene dato direttamente, trovare la posizione all'interno del vettore esistente è generalmente O (1). Tuttavia, se è necessario * cercare * il punto di inserimento (ad esempio, inserendo in un ordine ordinato), il tempo di ricerca stesso potrebbe essere O (n) o O (log n) a seconda dell'algoritmo di ricerca utilizzato (ricerca lineare o ricerca binaria, rispettivamente). Ma la parte mutevole domina.
2. Elementi mutevoli: Per fare spazio al nuovo elemento, tutti gli elementi * dopo * il punto di inserimento devono essere spostati a destra. Nel peggiore dei casi (inserendo all'inizio), devi spostare gli elementi `n`. Nel caso medio (inserendo nel mezzo), si sposta approssimativamente elementi `n/2`. In entrambi i casi, l'operazione di cambio contribuisce o (n) complessità temporale.
Tabella di riepilogo:
| Posizione di inserzione | Complessità temporale | Spiegazione |
| ---------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| Fine (push_back) | O (1) (ammortizzato) | Di solito tempo costante. La riallocazione può essere occasionalmente necessaria, ma per molti inserzioni, il tempo medio rimane vicino alla costante. |
| Posizione specifica | O (n) | Richiede lo spostamento di tutti gli elementi dopo il punto di inserimento. L'operazione mutevole domina la complessità temporale. Nota:se il punto di inserimento deve essere trovato cercando nel vettore, tale tempo di ricerca verrebbe aggiunto alla complessità totale. |
Considerazioni importanti:
* Rialocazione: Quando un vettore si esaurisce la capacità, deve riallocare un blocco più grande di memoria e copiare tutti gli elementi esistenti nel nuovo blocco. Questa operazione di riallocazione è O (n). Tuttavia, i vettori spesso raddoppiano la loro capacità ogni volta che riallocati, rendendo la riallocazione abbastanza poco frequente da ammortizzare il costo su molti inserzioni.
* Implementazione vettoriale: Le specifiche delle implementazioni vettoriali possono influire leggermente le prestazioni. Ad esempio, alcune implementazioni potrebbero utilizzare tecniche di gestione della memoria più sofisticate.
Esempio (C ++):
`` `CPP
#include
#include
int main () {
std ::vector
// Inserimento alla fine (ammortizzato O (1))
myvector.push_back (6);
std ::cout <<"dopo push_back:";
per (int x:myVector) std ::cout <
// Inserimento in una posizione specifica (O (N))
myVector.insert (myVector.begin () + 2, 10); // Inserisci 10 all'indice 2
std ::cout <<"Dopo inserire:";
per (int x:myVector) std ::cout <
restituzione 0;
}
`` `
In sintesi, sii consapevole di * dove * stai inserendo in un vettore. `Push_back` è tuo amico se devi solo aggiungere alla fine. Se è necessario inserire nel mezzo, considera le implicazioni delle prestazioni, soprattutto se stai facendo molti di questi inserimenti. Se sono necessari frequenti inserimenti medi, le strutture di dati alternative come elenchi collegati o alberi bilanciati potrebbero essere più adatte.
Informazioni correlate
software © www.354353.com