Skillnad mellan Array List och Linked List

Hur lagras data?

Array list och Linked List är vanliga termer när det gäller datalagring och hämtning. Även om det finns många lagringsenheter, beror de slutligen på lagringsmekanismen. Dessa två lagringsmekanismer placerar dina data i lagringsenheterna och hämtar dem vid behov. Låt oss ta en titt på hur de lagrar data i deras minne. Array-listan använder en sekventiell lagring, och datagrupperna lagras en efter en. Det här är kanske en enklare form av lagring - det undviker förvirring. Ja, vi kan hämta nästa objekt eller data från nästa minnesplats i matrislistan. Det lagras dock med hjälp av pekare på länken. Här behöver vi två minnesplatser för lagring - en för data, den andra för pekaren. En pekare adresserar minnesplatsen för nästa data. Vi kan lätt förstå att länklistan aldrig lagrar data i följd; snarare använder den en slumpmässig lagringsmekanism. Pointerna är de viktigaste elementen för att lokalisera datapunkterna i minnet.

Dynamisk Array och länklista

Vi har redan diskuterat hur båda lagringsmekanismerna lägger in data och vi kan ge termen "dynamisk array" för Array-listens interna lagringsschema. Det sätter bara data bitar efter varandra - det vill säga namnet - medan den länkade listan använder en intern lista med hjälp av pekare för att spåra nästa objekt. Därför använder den en intern länkad lista, som en ensam eller dubbel länkad lista för att visa oss nästa data.

Minnesanvändning

Eftersom Array-listan endast lagrar den faktiska data behöver vi bara plats för de data vi lagrar. Omvänt, i den länkade listan använder vi också pekare. Därför krävs två minnesplatser, och vi kan säga att länkad lista förbrukar mer minne än Array-listan. En fördelaktig sida av länkad lista är att det aldrig kräver kontinuerliga minnesplatser att lagra vår data, i motsats till Array-listan. Pekarna kan hålla positionen för nästa dataplacering, och vi kan till och med använda mindre minnesluckor som inte är kontinuerliga. När det gäller minnesanvändning spelar pekare huvudrollen i den länkade listan, och det gör också effektiviteten av dem.

Storlek på Initial Array List och Linked List

Med listan Array behöver även en tom lista en storlek på 10, men med en länkad lista behöver vi inte ett så stort utrymme. Vi kan skapa en tom länkad lista med en storlek på 0. Senare kan vi öka storleken efter behov.

Datainsamling

Datainsamling är enklare i Array-listan eftersom den lagras i följd. Allt det gör är att identifiera den första dataläget; därifrån kommer nästa plats åtkomst sekventiellt för att hämta resten. Den beräknar som den första datapositionen + 'n', där 'n' är ordningen för data i Array-listan. Den länkade listan hänvisar till den ursprungliga pekaren för att hitta den första dataläget, och därifrån hänvisar den pekaren som är associerad med varje data för att hitta nästa datalokation. Hämtningsprocessen är huvudsakligen beroende av pekarna här, och de visar oss på ett effektivt sätt nästa dataplacering.

Slut på data

Arraylistan använder ett nullvärde för att markera slutet på data, medan den länkade listan använder en nollpunktsgivare för detta ändamål. Så snart systemet känner igen nulldata, stoppar listan Array nästa datahämtning. På liknande sätt stoppar nollpunkten systemet från att fortsätta till nästa datahämtning.

Omvänd traversal

Den länkade listan tillåter oss att korsa i omvänd riktning med hjälp av descendingiterator (). Vi har emellertid inte en sådan möjlighet i en array-lista - omvänd traversal blir ett problem här.

Syntax

Låt oss titta på Java Syntax för båda lagringsmekanismerna.

Array list skapande:

Lista arraylistsample = new ArrayList ();

Lägga till objekt i arraylistan:

Arraylistsample.add ( ”namn1”);

Arraylistsample.add ( ”namn2”);

Så här kommer den resulterande Array-listan att se ut - [name1, name2].

Skapad länklista:

Lista linkedlistsample = new linkedList ();

Lägga till objekt i länklistan:

Linkedlistsample.add ( ”NAME3”);

Linkedlistsample.add ( ”NAME4”);

Så här kommer den resulterande länklistan att se ut - [namn3, namn4].

 Vilket är bättre för Get eller Search-funktionen?

Arraylistan tar O (1) tid för att köra någon datasökning, medan den länkade listan tar dig O (n) för n^th datasökning. Därför använder en Array-lista alltid en konstant tid för vilken datasökning som helst, men i den länkade listan beror tiden som är avhämtad av dataens position. Därför är Array-listor alltid ett bättre val för Get eller Search-operationer.

Vilket är bättre för införandet eller tilläggsoperationen?

Både Array-listan och den länkade listan tar O (1) tid för datadillägg. Men om arrayen är full, tar Array-listan lång tid att ändra storlek och kopiera objekten till den nyare. I så fall är länklistan det bättre valet.

Vilket är bättre för borttagningen?

Avlägsningsoperationen tar nästan samma tid i både Array-listan och den länkade listan. I Array-listan raderar denna operation dataen och ändrar sedan positionen för data för att bilda den nyare gruppen - det tar O (n) tid. I den länkade listan går denna operation till den specifika data och ändrar pekarpositioner för att bilda den nyare listan. Tiden för traversen och borttagningen är O (n) här också.

Vilket är snabbare?

Vi vet att en array-lista använder en intern array för att lagra den faktiska data. Därför, om någon data raderas, behöver alla kommande data ett minneskifte. Självklart kräver detta en avsevärd tid och sakta ner sakerna. Ett sådant minneskifte krävs inte i länklistan, eftersom allt det gör är att ändra pekarens plats. Därför är en länkad lista snabbare än en Array-lista i någon form av datalagring. Detta är emellertid endast beroende av typen av operation, dvs för Get or Search-operationen, tar den länkade listan mycket mer tid än en Array-lista. När vi tittar på övergripande prestanda kan vi säga att länklistan är snabbare.

När ska du använda en array-lista och en länkad lista?

En Array-lista passar bäst för mindre datakrav där kontinuerligt minne är tillgängligt. Men när vi hanterar enorma mängder data, utövar tillgängligheten av kontinuerligt minne datalagringsmekanismerna, oavsett om det är litet eller stort. Välj sedan vilken som ska väljas - Array-listan eller den länkade listan. Du kan gå vidare med en matrislista när du bara behöver lagra och hämta data. Men en lista kan hjälpa dig bortom det genom att manipulera data. När du väl bestämmer hur ofta datahantering krävs är det viktigt att kontrollera vilken typ av datahämtning du vanligtvis utför. När det bara är Få eller Sök, är Array List det bättre valet. För andra operationer, t.ex. Infoga eller Radera, fortsätt med den länkade listan.

Låt oss titta på skillnaderna i tabellform.

S.No	begrepp	skillnader
		Array List	Länkad lista
1	Data Lagring Mode	Använder sekventiell datalagring	Använder icke-sekventiell datalagring
2	Internt lagringssystem	Innehåller en intern dynamisk array	Håller en länkad lista
3	Minnesanvändning	Kräver minnesutrymme bara för data	Kräver också minnesutrymme för data för pekare
4	Storleken på den ursprungliga listan	Behöver plats för minst 10 objekt	Behöver inte utrymme och vi kan till och med skapa en tom länkad lista över storlek 0.
5	Datainsamling	Beräknar som den första datapositionen + 'n', där 'n' är ordningen för data i Array-listan	Förflyttning från första eller sista till den önskade data krävs
6	Slut på data	Null-värdena markerar slutet	Null Pointer markerar slutet
7	Omvänd traversal	Tillåt det inte	Tillåter det med hjälp av descendingiterator ()
8	Syntax för lista skapande	Lista arraylistsample = new ArrayList ();	Lista linkedlistsample = new linkedList ();
9	Lägga till objekt	Arraylistsample.add ( ”namn1”);	Linkedlistsample.add ( ”NAME3”);
10	Få eller sök	Tar O (1) tid och är bättre i prestanda	Tar O (n) tid och prestanda är beroende av dataens position
11	Infoga eller lägga till	Använder O (1) tid förutom när matrisen är full	Konsumerar O (1) tid under alla omständigheter
12	Radering eller borttagning	Tar O (n) tid	Tar O (n) tid
13	När ska du använda?	När det finns många Få eller Sök operationer involverade; Minnes tillgängligheten bör vara högre även i början	När det finns många Inlägg eller Ta bort operationer, och minnetillgängligheten inte behöver vara kontinuerlig