I programmering är listor och arrayer datastrukturer som används för att organisera och lagra data. Båda har sina unika egenskaper och syften. Listor är dynamisk och flexibel , vilket möjliggör enkel storleksändring under körning, medan matriser är statisk med en fixad storlek . Denna skillnad påverkar minnesanvändning och prestanda.
Innehållsförteckning
- Vad är listor?
- Vad är Arrays?
- Skillnaden mellan listor och matriser
- Implementering av listor
- Implementering av Arrays
Vad är listor?
Listor är en mångsidig datastruktur inom programmering, designad för att hålla en samling element med flexibilitet att hantera olika datatyper . Till skillnad från arrayer är listor dynamisk , vilket betyder att deras storlek kan ändras under körningen av ett program. Denna anpassningsförmåga gör listor särskilt användbara för uppgifter som involverar tillägg eller borttagning av element. Listor ger ett bekvämt gränssnitt för utvecklare att hantera och organisera data, vilket möjliggör effektiva operationer som t.ex bifogar , sätter in , eller Tar bort element. Möjligheten att dynamiskt justera deras storlek gör listor till ett kraftfullt verktyg för att hantera varierande mängder data i ett program.
Vad är Arrays?
Arrayer är en grundläggande datastruktur i programmering som låter dig lagra en samling av element i samma datatyp i ett sammanhängande minnesblock. Varje element i arrayen identifieras av ett index som representerar dess position. Det viktigaste kännetecknet för arrayer är att de erbjuder snabb och direkt tillgång till element med hjälp av dessa index. De tillhandahåller ett systematiskt sätt att organisera och hantera data, vilket gör det effektivt att hämta , ändra , och manipulera information lagrad i arrayen. Arrayer används ofta i olika programmeringsspråk för sin enkelhet och effektivitet vid hantering av ordnade uppsättningar av data.
Skillnaden mellan listor och matriser:
| Aspekt | Matriser | Listor |
|---|---|---|
| Storlek | Arrayer har en fast storlek inställd under skapandet. | Listor är dynamiska och kan ändras i storlek under körning. |
| Datatyper | Alla element i en array måste vara av samma datatyp. | Listor kan rymma element av olika datatyper. |
| Minnesallokering | Minne för hela arrayen allokeras på en gång under initieringen. | Listor tilldelar minne dynamiskt när element läggs till eller tas bort. |
| Åtkomsttid | Matriser ger konstant åtkomst till element genom indexering. | Listor kan ha något varierande åtkomsttid på grund av dynamisk storleksändring. |
| Flexibilitet | Arrayer är mindre flexibla eftersom deras storlek inte enkelt kan ändras. | Listor är mer flexibla, vilket gör det enkelt att lägga till eller ta bort element. |
| Minneseffektivitet maven installera | Kan leda till minnesförlust om storleken är större än nödvändigt. | Mer minneseffektivt tack vare dynamisk allokering. |
| Gemensamma implementeringar | Vanligt i språk som C/C++. | Vanligt i språk som Python och Java. |
Implementering av listor:
I det medföljande kodexemplet i Python initieras en lista för att lagra heltal (10, 20, 30). Element läggs till, nås via index, ändras och tas bort. I Python används append-metoden för tillägg och borttagning för radering. Exemplet visar de grundläggande funktionerna för att skapa, ändra och hantera listor i dessa programmeringsspråk.
C++
#include> #include> int> main() {> >// Creating an empty vector> >std::vector<>int>>myArray;> >// Adding elements to the vector> >myArray.push_back(10);> >myArray.push_back(20);> >myArray.push_back(30);> >// Displaying the elements in the vector> >std::cout <<>'Elements in the vector: '>;> >for> (>int> num : myArray) {> >std::cout << num <<>' '>;> >}> >std::cout << std::endl;> >// Accessing elements by index> >int> firstElement = myArray[0];> >int> secondElement = myArray[1];> >// Modifying an element> >myArray[1] = 25;> >// Removing an element by value> >for> (>auto> it = myArray.begin(); it != myArray.end(); ++it) {> >if> (*it == 30) {> >myArray.erase(it);> >break>;> >}> >}> >// Displaying the updated vector> >std::cout <<>'Updated vector: '>;> >for> (>int> num : myArray) {> >std::cout << num <<>' '>;> >}> >std::cout << std::endl;> >return> 0;> }> // This code is contributed by shivamgupta0987654321> |
>
>
Java
import> java.util.ArrayList;> import> java.util.Iterator;> public> class> Main {> >public> static> void> main(String[] args)> >{> >// Creating an empty ArrayList> >ArrayList myArray =>new> ArrayList();> >// Adding elements to the ArrayList> >myArray.add(>10>);> >myArray.add(>20>);> >myArray.add(>30>);> >// Displaying the elements in the ArrayList> >System.out.print(>'Elements in the ArrayList: '>);> >for> (>int> num : myArray) {> >System.out.print(num +>' '>);> >}> >System.out.println();> >// Accessing elements by index> >int> firstElement = myArray.get(>0>);> >int> secondElement = myArray.get(>1>);> >// Modifying an element> >myArray.set(>1>,>25>);> >// Removing an element by value> >Iterator iterator = myArray.iterator();> >while> (iterator.hasNext()) {> >int> element = iterator.next();> >if> (element ==>30>) {> >iterator.remove();> >break>;> >}> >}> >// Displaying the updated ArrayList> >System.out.print(>'Updated ArrayList: '>);> >for> (>int> num : myArray) {> >System.out.print(num +>' '>);> >}> >System.out.println();> >}> }> |
>
>
Python3
# Creating an empty list> my_list>=> []> # Adding elements to the list> my_list.append(>10>)> my_list.append(>20>)> my_list.append(>30>)> # Displaying the elements in the list> print>('Elements>in> the>list>:', my_list)> # Accessing elements by index> first_element>=> my_list[>0>]> second_element>=> my_list[>1>]> # Modifying an element> my_list[>1>]>=> 25> # Removing an element> my_list.remove(>30>)> # Displaying the updated list> print>('Updated>list>:', my_list)> |
>
>
C#
using> System;> using> System.Collections.Generic;> class> Program> {> >static> void> Main()> >{> >// Creating an empty list> >List<>int>>myArray =>new> List<>int>>();> >// Adding elements to the list> >myArray.Add(10);> >myArray.Add(20);> >myArray.Add(30);> >// Displaying the elements in the list> >Console.Write(>'Elements in the list: '>);> >foreach> (>int> num>in> myArray)> >{> >Console.Write(num +>' '>);> >}> >Console.WriteLine();> >// Accessing elements by index> >int> firstElement = myArray[0];> >int> secondElement = myArray[1];> >// Modifying an element> >myArray[1] = 25;> >// Removing an element by value> >for> (>int> i = 0; i { if (myArray[i] == 30) { myArray.RemoveAt(i); break; } } // Displaying the updated list Console.Write('Updated list: '); foreach (int num in myArray) { Console.Write(num + ' '); } Console.WriteLine(); } }> |
>
>
Javascript
heltal till dubbel java
// Creating an empty array> let myArray = [];> // Adding elements to the array> myArray.push(10);> myArray.push(20);> myArray.push(30);> // Displaying the elements in the array> console.log(>'Elements in the array:'>, myArray);> // Accessing elements by index> let firstElement = myArray[0];> let secondElement = myArray[1];> // Modifying an element> myArray[1] = 25;> // Removing an element (in this case, removing by value)> let indexToRemove = myArray.indexOf(30);> if> (indexToRemove !== -1) {> >myArray.splice(indexToRemove, 1);> }> // Displaying the updated array> console.log(>'Updated array:'>, myArray);> |
>
>Produktion
Elements in the vector: 10 20 30 Updated vector: 10 25>
Implementering av arrayer:
I C++, C, Python, Java och JavaScript skapar koden en array med element (10, 20, 30), kommer åt och ändrar element efter index och visar den uppdaterade arrayen. Syntaxen och specifika metoder skiljer sig åt mellan olika språk, men de grundläggande arrayoperationerna förblir konsekventa och visar hur man manipulerar och itererar genom arrayer.
C++
#include> using> namespace> std;> int> main() {> >// Creating an array> >int> myArray[3] = {10, 20, 30};> >// Accessing elements by index> >int> firstElement = myArray[0];> >int> secondElement = myArray[1];> >// Modifying an element> >myArray[1] = 25;> >// Displaying the elements in the array> >for> (>int> i = 0; i <3; ++i) {> >cout << myArray[i] << ' ';> >}> >return> 0;> }> |
>
>
C
#include> int> main() {> >// Creating an array> >int> myArray[3] = {10, 20, 30};> >// Accessing elements by index> >int> firstElement = myArray[0];> >int> secondElement = myArray[1];> >// Modifying an element> >myArray[1] = 25;> >// Displaying the elements in the array> >for> (>int> i = 0; i <3; ++i) {> >printf>('%d ', myArray[i]);> >}> >return> 0;> }> |
>
>
Java
public> class> ArrayExample {> >public> static> void> main(String[] args) {> >// Creating an array> >int>[] myArray = {>10>,>20>,>30>};> >// Accessing elements by index> >int> firstElement = myArray[>0>];> >int> secondElement = myArray[>1>];> >// Modifying an element> >myArray[>1>] =>25>;> >// Displaying the elements in the array> >for> (>int> i =>0>; i <>3>; ++i) {> >System.out.print(myArray[i] + ' ');> >}> >}> }> |
>
>
Python3
# Creating an array (using a list)> my_array>=> [>10>,>20>,>30>]> # Accessing elements by index> first_element>=> my_array[>0>]> second_element>=> my_array[>1>]> # Modifying an element> my_array[>1>]>=> 25> # Displaying the elements in the array> for> element>in> my_array:> >print>(element, end>=>' ')> |
>
>
C#
using> System;> class> Program> {> >static> void> Main()> >{> >// Creating an array> >int>[] myArray = { 10, 20, 30 };> >// Modifying an element> >myArray[1] = 25;> >// Displaying the elements in the array> >foreach> (>int> element>in> myArray)> >{> >Console.Write(element + ' ');> >}> >}> }> |
>
>
Javascript
// Creating an array> let myArray = [10, 20, 30];> // Accessing elements by index> let firstElement = myArray[0];> let secondElement = myArray[1];> // Modifying an element> myArray[1] = 25;> // Displaying the elements in the array> for> (let i = 0; i console.log(myArray[i]); }> |
>
>Produktion
10 25 30>
Sammanfattningsvis erbjuder arrayer en fixad storlek , sammanhängande minnesstruktur med effektiv tillgång till element medan listor ger dynamisk dimensionering , flexibilitet , och inbyggda metoder för att underlätta manipulation. Valet mellan de två beror på de specifika kraven för applikationen, med arrayer som utmärker sig i scenarier där fast storlek och direkt minnesåtkomst är avgörande, och listor som visar sig vara fördelaktiga för dynamisk data och olika operationer. Genom att förstå de unika egenskaperna hos varje datastruktur kan utvecklare fatta välgrundade beslut baserat på kraven från deras programmeringsuppgifter.