Matrice contro elenco collegato

Perché qualcuno dovrebbe voler utilizzare un elenco collegato su un array?

La codifica di un elenco collegato è, senza dubbio, un po 'più impegnativa rispetto all'utilizzo di un array e ci si potrebbe chiedere cosa giustificherebbe lo sforzo aggiuntivo.

Penso che l'inserimento di nuovi elementi sia banale in una lista collegata, ma è un lavoro importante in un array. Ci sono altri vantaggi nell'utilizzare un elenco collegato per archiviare un set di dati rispetto alla loro memorizzazione in un array?

Questa domanda non è un duplicato di questa domanda perché l'altra domanda si pone specificamente su una particolare classe Java mentre questa domanda riguarda le strutture di dati generali.

• È più facile archiviare dati di dimensioni diverse in un elenco collegato. Un array presuppone che ogni elemento abbia esattamente le stesse dimensioni.
• Come hai detto, è più facile che un elenco collegato cresca organicamente. Le dimensioni di un array devono essere conosciute in anticipo o ricreate quando devono crescere.
• Mescolare un elenco collegato è solo una questione di cambiare ciò che punta a cosa. Mescolare un array è più complicato e / o richiede più memoria.
• Finché le iterazioni avvengono tutte in un contesto "foreach", non si perde alcuna performance nell'iterazione.

Un altro buon motivo è che gli elenchi collegati si prestano bene a implementazioni multi-thread efficienti. La ragione di ciò è che le modifiche tendono ad essere locali, interessando solo un puntatore o due per l'inserimento e la rimozione in una parte localizzata della struttura dei dati. Quindi, puoi avere molti thread che lavorano sullo stesso elenco collegato. Ancora di più, è possibile creare versioni senza blocco utilizzando operazioni di tipo CAS ed evitare del tutto i blocchi pesanti.

Con un elenco collegato, gli iteratori possono anche attraversare l'elenco mentre si verificano modifiche. Nel caso ottimistico in cui le modifiche non si scontrano, gli iteratori possono continuare senza contese.

Con un array, è probabile che qualsiasi modifica che modifichi le dimensioni dell'array richieda il blocco di gran parte dell'array e, in effetti, è raro che ciò avvenga senza un blocco globale nell'intero array, in modo che le modifiche diventino fermare gli affari del mondo.

Wikipedia ha un'ottima sezione sulle differenze.

Gli elenchi collegati presentano numerosi vantaggi rispetto agli array. Gli elementi possono essere inseriti in elenchi collegati indefinitamente, mentre un array alla fine si riempie o deve essere ridimensionato, un'operazione costosa che potrebbe non essere possibile anche se la memoria è frammentata. Allo stesso modo, un array da cui vengono rimossi molti elementi può diventare inutilmente vuoto o deve essere ridotto.

D'altra parte, gli array consentono l'accesso casuale, mentre gli elenchi collegati consentono solo l'accesso sequenziale agli elementi. Gli elenchi collegati singolarmente, infatti, possono essere attraversati solo in una direzione. Ciò rende gli elenchi collegati non adatti alle applicazioni in cui è utile cercare rapidamente un elemento in base al suo indice, ad esempio heapsort. L'accesso sequenziale su array è anche più veloce rispetto agli elenchi collegati su molte macchine a causa della localizzazione delle cache di riferimento e dei dati. Gli elenchi collegati non ricevono quasi alcun vantaggio dalla cache.

Un altro svantaggio degli elenchi collegati è la memoria aggiuntiva necessaria per i riferimenti, che spesso li rende poco pratici per elenchi di piccoli elementi di dati come caratteri o valori booleani. Può anche essere lento e con un allocatore ingenuo, dispendioso, allocare la memoria separatamente per ogni nuovo elemento, un problema generalmente risolto usando i pool di memoria.

http://en.wikipedia.org/wiki/Linked_list

Ne aggiungerò un altro: le liste possono agire come puramente funzionali strutture di dati .

Ad esempio, puoi avere elenchi completamente diversi che condividono la stessa sezione finale

a = (1 2 3 4, ....)
b = (4 3 2 1 1 2 3 4 ...)
c = (3 4 ...)

vale a dire:

b = 4 -> 3 -> 2 -> 1 -> a
c = a.next.next  

senza dover copiare i dati indicati da ain bec .

Questo è il motivo per cui sono così popolari nei linguaggi funzionali, che usano variabili immutabili - prepende le tailoperazioni possono avvenire liberamente senza dover copiare i dati originali - caratteristiche molto importanti quando si trattano i dati come immutabili.

Oltre ad essere più facile da inserire al centro dell'elenco, è anche molto più facile eliminare dal centro di un elenco collegato piuttosto che un array.

Ma francamente, non ho mai usato un elenco collegato. Ogni volta che avevo bisogno di inserimento e cancellazione veloce, avevo anche bisogno di una ricerca veloce, quindi sono andato a un HashSet o un dizionario.

L'unione di due elenchi collegati (in particolare due elenchi doppiamente collegati) è molto più rapida rispetto all'unione di due array (supponendo che l'unione sia distruttiva). Il primo prende O (1), il secondo prende O (n).

EDIT: Per chiarire, intendevo "fondere" qui in senso non ordinato, non come in ordine di fusione. Forse "concatenare" sarebbe stata una parola migliore.

Un argomento ampiamente non apprezzato per ArrayList e contro LinkedList è che i LinkedList sono scomodi durante il debug . Il tempo impiegato dagli sviluppatori di manutenzione per comprendere il programma, ad esempio per individuare bug, aumenti e IMHO a volte non giustifica i nanosecondi in miglioramenti delle prestazioni o byte nel consumo di memoria nelle applicazioni aziendali. A volte (beh, ovviamente dipende dal tipo di applicazioni), è meglio perdere qualche byte ma avere un'applicazione che è più gestibile o più facile da capire.

Ad esempio, in un ambiente Java e usando il debugger Eclipse, il debug di una ArrayList rivelerà una struttura molto facile da capire:

arrayList   ArrayList<String>
  elementData   Object[]
    [0] Object  "Foo"
    [1] Object  "Foo"
    [2] Object  "Foo"
    [3] Object  "Foo"
    [4] Object  "Foo"
    ...

D'altra parte, guardare il contenuto di una LinkedList e trovare oggetti specifici diventa un incubo facendo clic su Espandi-l'albero, per non parlare del sovraccarico cognitivo necessario per filtrare gli interni di LinkedList:

linkedList  LinkedList<String>
    header  LinkedList$Entry<E>
        element E
        next    LinkedList$Entry<E>
            element E   "Foo"
            next    LinkedList$Entry<E>
                element E   "Foo"
                next    LinkedList$Entry<E>
                    element E   "Foo"
                    next    LinkedList$Entry<E>
                    previous    LinkedList$Entry<E>
                    ...
                previous    LinkedList$Entry<E>
            previous    LinkedList$Entry<E>
        previous    LinkedList$Entry<E>

Prima di tutto, nelle liste collegate in C ++ non dovrebbe esserci molto più problema con cui lavorare rispetto a un array. È possibile utilizzare l' elenco std :: o l' elenco puntatore boost per gli elenchi collegati. I problemi chiave con gli elenchi collegati rispetto agli array sono lo spazio aggiuntivo necessario per i puntatori e il terribile accesso casuale. È necessario utilizzare un elenco collegato se

• non è necessario un accesso casuale ai dati
• aggiungerai / eliminerai elementi, specialmente in mezzo alla lista

Per me è così,

1. Accesso

   • Gli elenchi collegati consentono solo l'accesso sequenziale agli elementi. Quindi la complessità algoritmica è l'ordine di O (n)
   • Le matrici consentono l'accesso casuale ai suoi elementi e quindi la complessità è dell'ordine di O (1)

2. Conservazione

   • Gli elenchi collegati richiedono una memoria aggiuntiva per i riferimenti. Ciò li rende poco pratici per elenchi di piccoli elementi di dati come caratteri o valori booleani.
   • Le matrici non necessitano di spazio di archiviazione aggiuntivo per puntare all'elemento di dati successivo. È possibile accedere a ciascun elemento tramite indici.

3. Taglia

   • La dimensione degli elenchi collegati è dinamica per natura.
   • La dimensione dell'array è limitata alla dichiarazione.

4. Inserzione / delezione

   • Gli elementi possono essere inseriti ed eliminati in elenchi collegati a tempo indeterminato.
   • L'inserimento / cancellazione di valori negli array è molto costoso. Richiede la riallocazione della memoria.

Due cose:

La codifica di un elenco collegato è, senza dubbio, un po 'più impegnativa rispetto all'utilizzo di un array e si chiedeva cosa avrebbe giustificato lo sforzo aggiuntivo.

Non codificare mai un elenco collegato quando si utilizza C ++. Basta usare l'STL. Quanto sia difficile da implementare non dovrebbe mai essere un motivo per scegliere una struttura di dati piuttosto che un'altra perché la maggior parte è già implementata là fuori.

Per quanto riguarda le effettive differenze tra un array e un elenco collegato, la cosa importante per me è come pensi di utilizzare la struttura. Userò il termine vettore poiché è il termine per un array ridimensionabile in C ++.

L'indicizzazione in un elenco collegato è lenta perché è necessario attraversare l'elenco per raggiungere l'indice dato, mentre un vettore è contiguo in memoria e puoi arrivarci utilizzando la matematica del puntatore.

L'aggiunta alla fine o all'inizio di un elenco collegato è facile, poiché è necessario aggiornare solo un collegamento, in cui in un vettore potrebbe essere necessario ridimensionare e copiare il contenuto.

Rimuovere un elemento da un elenco è facile, poiché devi solo rompere una coppia di collegamenti e quindi ricollegarli. La rimozione di un oggetto da un vettore può essere più veloce o più lenta, a seconda se ti interessa l'ordine. Scambiare l'ultimo elemento sopra l'elemento che si desidera rimuovere è più veloce, mentre lo spostamento di tutto ciò che lo segue è più lento, ma mantiene l'ordine.

Eric Lippert ha recentemente pubblicato un post su uno dei motivi per cui gli array devono essere usati in modo conservativo.

L'inserimento e la rimozione rapidi sono in effetti gli argomenti migliori per gli elenchi collegati. Se la tua struttura cresce in modo dinamico e non è necessario l'accesso a tempo costante a qualsiasi elemento (come stack e code dinamici), gli elenchi collegati sono una buona scelta.

Eccone uno veloce: la rimozione degli oggetti è più rapida.

Gli elenchi collegati sono particolarmente utili quando la raccolta è in costante crescita e riduzione. Ad esempio, è difficile immaginare di provare a implementare una coda (aggiungere alla fine, rimuovere dalla parte anteriore) usando un array: passeresti tutto il tempo a spostare le cose verso il basso. D'altra parte, è banale con una lista collegata.

Oltre ad aggiungere e rimuovere dal centro dell'elenco, mi piacciono di più gli elenchi collegati perché possono crescere e ridursi dinamicamente.

Nessuno codifica più il proprio elenco di link. Sarebbe sciocco. La premessa che l'utilizzo di un elenco collegato richiede più codice è semplicemente errato.

In questi giorni, la creazione di un elenco collegato è solo un esercizio per gli studenti in modo che possano capire il concetto. Al contrario, tutti usano un elenco predefinito. In C ++, basato sulla descrizione nella nostra domanda, ciò significherebbe probabilmente un vettore stl (#include <vector> ).

Pertanto, la scelta di un elenco collegato rispetto a un array si basa esclusivamente sulla valutazione delle diverse caratteristiche di ciascuna struttura in relazione alle esigenze dell'app. Il superamento dell'onere di programmazione aggiuntivo dovrebbe avere un impatto zero sulla decisione.

È davvero una questione di efficienza, l'overhead per inserire, rimuovere o spostare (dove non si sta semplicemente scambiando) elementi all'interno di un elenco collegato è minimo, ovvero l'operazione stessa è O (1), versi O (n) per un array. Ciò può fare una differenza significativa se si sta operando pesantemente su un elenco di dati. Hai scelto i tuoi tipi di dati in base a come opererai su di essi e scegli il più efficiente per l'algoritmo che stai utilizzando.

Le matrici hanno senso dove sarà noto il numero esatto di elementi e dove ha senso la ricerca per indice. Ad esempio, se volessi memorizzare lo stato esatto della mia uscita video in un determinato momento senza compressione, probabilmente utilizzerei un array di dimensioni [1024] [768]. Questo mi fornirà esattamente ciò di cui ho bisogno e un elenco sarebbe molto, molto più lento per ottenere il valore di un determinato pixel. Nei luoghi in cui un array non ha senso, in genere esistono tipi di dati migliori di un elenco per gestire i dati in modo efficace.

Array Vs Elenco collegato:

1. L'allocazione della memoria dell'array a volte fallirà a causa della memoria frammentata.
2. La memorizzazione nella cache è migliore negli array poiché a tutti gli elementi viene assegnato spazio di memoria contiguo.
3. La codifica è più complessa delle matrici.
4. Nessun limite di dimensione sull'elenco collegato, a differenza degli array
5. L'inserimento / eliminazione è più rapido nell'elenco collegato e l'accesso è più veloce negli array.
6. Elenco collegato meglio dal punto di vista multi-thread.

poiché gli array sono di natura statica, quindi tutte le operazioni come l'allocazione della memoria avvengono solo al momento della compilazione. Quindi il processore deve dedicare meno sforzi al suo runtime.

Supponiamo di avere un set ordinato, che si desidera modificare anche aggiungendo e rimuovendo elementi. Inoltre, è necessaria la capacità di conservare un riferimento a un elemento in modo tale che in seguito sia possibile ottenere un elemento precedente o successivo. Ad esempio, un elenco di cose da fare o una serie di paragrafi in un libro.

Per prima cosa dovremmo notare che se si desidera conservare i riferimenti ad oggetti al di fuori dell'insieme stesso, probabilmente si finirà per archiviare i puntatori nella matrice, piuttosto che memorizzare gli oggetti stessi. Altrimenti non sarai in grado di inserire nell'array - se gli oggetti sono incorporati nell'array si sposteranno durante gli inserimenti e tutti i puntatori a essi diventeranno non validi. Lo stesso vale per gli indici di array.

Il tuo primo problema, come hai notato tu stesso, è l'inserimento - l'elenco collegato consente l'inserimento in O (1), ma un array generalmente richiede O (n). Questo problema può essere parzialmente risolto: è possibile creare una struttura di dati che offra un'interfaccia di accesso ordinaria simile a una matrice in cui sia la lettura che la scrittura sono, nella peggiore delle ipotesi, logaritmiche.

Il tuo secondo e più grave problema è che dato un elemento che trova l'elemento successivo è O (n). Se l'insieme non è stato modificato, è possibile mantenere l'indice dell'elemento come riferimento anziché come puntatore, rendendo in tal modo un'operazione successiva (O), ma poiché è tutto ciò che si ha è un puntatore all'oggetto stesso e in nessun modo per determinare il suo indice corrente nell'array diverso dalla scansione dell'intero "array". Questo è un problema insormontabile per gli array: anche se è possibile ottimizzare gli inserimenti, non è possibile fare nulla per ottimizzare l'operazione di ricerca del tipo successivo.

In un array hai il privilegio di accedere a qualsiasi elemento nel tempo O (1). Quindi è adatto per operazioni come la ricerca binaria Ordinamento rapido, ecc. L'elenco collegato d'altra parte è adatto per la cancellazione di inserimenti come nel tempo O (1). Entrambi hanno vantaggi e svantaggi e preferire l'uno all'altro si riduce a ciò che si desidera implementare.

- La domanda più grande è: possiamo avere un ibrido di entrambi. Qualcosa di simile a ciò che python e perl implementano come liste.

Lista collegata

È più preferibile quando si tratta di inserimento! Fondamentalmente ciò che fa è che si occupa del puntatore

1 -> 3 -> 4

Inserisci (2)

1 ........ 3 ...... 4
..... 2

Finalmente

1 -> 2 -> 3 -> 4

Una freccia dai 2 punti a 3 e la freccia da 1 punti a 2

Semplice!

Ma dall'array

| 1 | 3 | 4 |

Inserisci (2) | 1 | 3 | | 4 | | 1 | | 3 | 4 | | 1 | 2 | 3 | 4 |

Bene, chiunque può visualizzare la differenza! Solo per 4 indici stiamo eseguendo 3 passaggi

E se la lunghezza dell'array fosse un milione allora? L'array è efficiente? La risposta è no! :)

La stessa cosa vale per la cancellazione! In Elenco collegato possiamo semplicemente usare il puntatore e annullare l'elemento e successivamente nella classe di oggetti! Ma per l'array, dobbiamo eseguire shiftLeft ()

Spero che aiuti! :)

L'Elenco collegato è più un overhead da mantenere rispetto all'array, inoltre richiede una memoria aggiuntiva che tutti questi punti sono concordati. Ma ci sono alcune cose che array non può fare. In molti casi supponiamo che tu voglia un array di lunghezza 10 ^ 9 che non puoi ottenerlo perché deve trovarsi una posizione di memoria continua. Elenco collegato potrebbe essere un salvatore qui.

Supponiamo di voler archiviare più cose con i dati, in modo che possano essere facilmente estese nell'elenco collegato.

I contenitori STL di solito hanno un'implementazione dell'elenco collegato dietro la scena.

1- L' elenco collegato è una struttura di dati dinamica in modo che possa crescere e ridursi in fase di esecuzione allocando e deallocando la memoria. Quindi non è necessario fornire una dimensione iniziale dell'elenco collegato. L'inserimento e la cancellazione di nodi sono davvero più facili.

Le dimensioni 2- dell'elenco collegato possono aumentare o diminuire in fase di esecuzione, quindi non c'è spreco di memoria. Nel caso dell'array, c'è un sacco di spreco di memoria, come se dichiarassimo un array di dimensioni 10 e memorizzassimo solo 6 elementi, lo spazio di 4 elementi viene sprecato. Non esiste alcun problema nell'elenco collegato poiché la memoria viene allocata solo quando richiesto.

3- Strutture di dati come stack e code possono essere facilmente implementate utilizzando l'elenco collegato.

L'unico motivo per utilizzare l'elenco collegato è che inserire l'elemento è facile (rimuovendo anche).

Disadvatige potrebbe essere che i puntatori occupano molto spazio.

E su quel codice è più difficile: di solito non hai bisogno di un elenco di codici (o solo una volta) che sono inclusi in STL e non è così complicato se devi ancora farlo.

penso anche che l'elenco dei collegamenti sia più efficace degli array. perché attraversiamo nell'elenco dei collegamenti ma non negli array

A seconda della lingua, alcuni di questi svantaggi e vantaggi potrebbero essere considerati:

C Linguaggio di programmazione : quando si utilizza un elenco collegato (in genere tramite puntatori a struttura), è necessario prestare particolare attenzione a non perdere la memoria. Come accennato in precedenza, gli elenchi collegati sono facili da mescolare, perché tutto ciò che stava facendo è cambiare i puntatori, ma ricorderemo di liberare tutto?

Java : Java ha un garbage collection automatico, quindi la perdita di memoria non sarà un problema, ma nascosti dal programmatore di alto livello sono i dettagli di implementazione di ciò che è un elenco collegato. Metodi come la rimozione di un nodo dal centro dell'elenco sono più complicati di una procedura di quanto alcuni utenti della lingua si aspetterebbero.

Perché un elenco collegato su un array? Come alcuni hanno già detto, maggiore velocità di inserzioni ed eliminazioni.

Ma forse non dobbiamo vivere con i limiti di nessuno dei due e ottenere il meglio da entrambi, allo stesso tempo ... eh?

Per le eliminazioni di array, è possibile utilizzare un byte "Eliminato", per rappresentare il fatto che una riga è stata eliminata, pertanto non è più necessario riprogrammare l'array. Per alleviare l'onere degli inserimenti o la rapida modifica dei dati, utilizzare un elenco collegato per quello. Quindi, quando ti riferisci a loro, fai prima cercare la tua logica, poi l'altra. Quindi, usarli in combinazione ti dà il meglio di entrambi.

Se si dispone di un array davvero grande, è possibile combinarlo con un altro array o elenco collegato molto più piccolo in cui quello più piccolo contiene 20, 50, 100 elementi utilizzati più di recente. Se quello necessario non si trova nell'elenco o nell'array collegato più breve, si passa all'array di grandi dimensioni. Se trovato lì, puoi quindi aggiungerlo all'elenco / array collegato più piccolo presumendo che "le cose usate più di recente sono più simili a riutilizzare" (e sì, probabilmente eliminando dall'elenco l'elenco degli elementi utilizzati più di recente). Il che è vero in molti casi e risolto un problema che ho dovuto affrontare in un modulo di controllo delle autorizzazioni di sicurezza .ASP, con facilità, eleganza e velocità impressionante.

Mentre molti di voi hanno toccato i principali vantaggi / dislivelli dell'elenco collegato rispetto all'array, la maggior parte dei confronti riguarda il modo in cui uno è migliore / peggiore dell'altro. è possibile eseguire l'accesso casuale in array ma non è possibile nell'elenco collegato e altri. Tuttavia, ciò presuppone che gli elenchi di collegamenti e l'array verranno applicati in un'applicazione simile. Tuttavia, una risposta corretta dovrebbe essere come l'elenco di collegamenti sarebbe preferito sull'array e viceversa in una particolare distribuzione dell'applicazione. Supponiamo che tu voglia implementare un'applicazione per dizionari, cosa useresti? Matrice: mmm consentirebbe un facile recupero attraverso la ricerca binaria e altri algoritmi di ricerca .. ma lasciamo pensare a come l'elenco dei collegamenti può essere migliore..Sicuro che si desidera cercare "BLOB" nel dizionario. Avrebbe senso avere un elenco di collegamenti di A-> B-> C-> D ---->

A -> B -> C -> ...Z
|    |    |
|    |    [Cat, Cave]
|    [Banana, Blob]
[Adam, Apple]

Ora l'approccio sopra è migliore o una matrice piatta di [Adam, Apple, Banana, Blob, Cat, Cave]? Sarebbe possibile anche con l'array? Quindi un grande vantaggio dell'elenco dei collegamenti è che puoi avere un elemento che non punta solo all'elemento successivo ma anche a qualche altro elenco di collegamenti / array / heap / o qualsiasi altra posizione di memoria. L'array è una memoria contigua piatta suddivisa in blocchi di dimensioni dell'elemento che sta per memorizzare. L'elenco dei collegamenti d'altra parte è un gruppo di unità di memoria non contigue (può essere di qualsiasi dimensione e contenere qualsiasi cosa) e puntare a ciascuna altro come vuoi tu. Allo stesso modo diciamo che stai creando un'unità USB. Ora desideri che i file vengano salvati come array o come elenco di collegamenti? Penso che tu abbia l'idea di cosa sto indicando :)