Nella programmazione, elenchi e array sono strutture dati utilizzate per organizzare e archiviare dati. Entrambi hanno le loro caratteristiche e scopi unici. Elenchi Sono dinamico E flessibile , consentendo un facile ridimensionamento durante il runtime, mentre matrici Sono statico con un taglia unica . Questa differenza influisce sull'utilizzo e sulle prestazioni della memoria.
Tabella dei contenuti
- Cosa sono le Liste?
- Cosa sono gli Array?
- Differenza tra elenchi e matrici
- Attuazione delle liste
- Implementazione di array
Cosa sono le Liste?
Gli elenchi sono una struttura dati versatile nella programmazione, progettata per contenere una raccolta di elementi con la flessibilità di gestione diversi tipi di dati . A differenza degli array, gli elenchi lo sono dinamico , il che significa che la loro dimensione può cambiare durante l'esecuzione di un programma. Questa adattabilità rende gli elenchi particolarmente utili per attività che comportano l'aggiunta o la rimozione di elementi. Gli elenchi forniscono agli sviluppatori un'interfaccia pratica per gestire e organizzare i dati, consentendo operazioni efficienti come aggiungendo , inserendo , O eliminazione elementi. La possibilità di adattarne dinamicamente le dimensioni rende gli elenchi uno strumento potente per gestire quantità variabili di dati in un programma.
Cosa sono gli Array?
Gli array sono una struttura dati fondamentale nella programmazione che consente di memorizzare una raccolta di elementi del file stesso tipo di dati in un blocco di memoria contiguo. Ogni elemento dell'array è identificato da un indice, che ne rappresenta la posizione. La caratteristica chiave degli array è che offrono un accesso rapido e diretto agli elementi utilizzando questi indici. Forniscono un modo sistematico per organizzare e gestire i dati, rendendoli efficienti recuperare , modificare , E manipolare informazioni memorizzate nell'array. Gli array sono ampiamente utilizzati in vari linguaggi di programmazione per la loro semplicità ed efficacia nella gestione di insiemi ordinati di dati.
Differenza tra elenchi e matrici:
| Aspetto | Array | Elenchi |
|---|---|---|
| Misurare | Gli array hanno una dimensione fissa impostata durante la creazione. | Gli elenchi sono dinamici e possono cambiare di dimensioni durante il runtime. |
| Tipi di dati | Tutti gli elementi di un array devono avere lo stesso tipo di dati. | Gli elenchi possono contenere elementi di diversi tipi di dati. |
| Allocazione della memoria | La memoria per l'intero array viene allocata contemporaneamente durante l'inizializzazione. | Gli elenchi allocano dinamicamente la memoria man mano che gli elementi vengono aggiunti o rimossi. |
| Orario di accesso | Gli array forniscono accesso costante agli elementi tramite l'indicizzazione. | Le liste potrebbero avere tempi di accesso leggermente variabili a causa del ridimensionamento dinamico. |
| Flessibilità | Gli array sono meno flessibili poiché la loro dimensione non può essere modificata facilmente. | Gli elenchi sono più flessibili e consentono una facile aggiunta o rimozione di elementi. |
| Efficienza della memoria pitone di inserimento | Potrebbe portare a uno spreco di memoria se la dimensione è maggiore del necessario. | Maggiore efficienza in termini di memoria grazie all'allocazione dinamica. |
| Implementazioni comuni | Comune in linguaggi come C/C++. | Comune in linguaggi come Python e Java. |
Implementazione degli elenchi:
Nell'esempio di codice fornito in Python, un elenco viene inizializzato per archiviare numeri interi (10, 20, 30). Gli elementi vengono aggiunti, accessibili tramite indice, modificati e rimossi. In Python, il metodo append viene utilizzato per l'aggiunta e rimuovi per la cancellazione. L'esempio illustra le operazioni fondamentali di creazione, modifica e gestione degli elenchi in questi linguaggi di programmazione.
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> |
>
>
Giava
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
// 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);> |
>
>
pendenza indefinitaProduzione
Elements in the vector: 10 20 30 Updated vector: 10 25>
Implementazione degli array:
In C++, C, Python, Java e JavaScript, il codice crea un array con elementi (10, 20, 30), accede e modifica gli elementi in base all'indice e visualizza l'array aggiornato. La sintassi e i metodi specifici differiscono tra i linguaggi, ma le operazioni fondamentali sugli array rimangono coerenti, mostrando come manipolare e scorrere gli array.
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;> }> |
>
>
Giava
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]); }> |
>
>Produzione
10 25 30>
In conclusione, gli array offrono a taglia unica , struttura della memoria contigua con accesso efficiente agli elementi mentre gli elenchi forniscono dimensionamento dinamico , flessibilità , E metodi integrati per facilità di manipolazione. La scelta tra i due dipende dai requisiti specifici dell'applicazione, con gli array che eccellono in scenari in cui le dimensioni fisse e l'accesso diretto alla memoria sono critici, e gli elenchi che si rivelano vantaggiosi per dati dinamici e operazioni diversificate. In definitiva, comprendere le caratteristiche uniche di ciascuna struttura dati consente agli sviluppatori di prendere decisioni informate in base alle esigenze delle loro attività di programmazione.