En programació, les llistes i les matrius són estructures de dades utilitzades per organitzar i emmagatzemar dades. Tots dos tenen les seves característiques i finalitats úniques. Llistes són dinàmic i flexible , permetent un fàcil redimensionament durant el temps d'execució, mentre matrius són estàtica amb una mida fixa . Aquesta diferència afecta l'ús i el rendiment de la memòria.
Taula de contingut
- Què són les llistes?
- Què són els Arrays?
- Diferència entre llistes i matrius
- Implementació de Llistes
- Implementació de Arrays
Què són les llistes?
Les llistes són una estructura de dades versàtil en programació, dissenyada per contenir una col·lecció d'elements amb la flexibilitat de manejar diferents tipus de dades . A diferència de les matrius, les llistes ho són dinàmic , és a dir, la seva mida pot canviar durant l'execució d'un programa. Aquesta adaptabilitat fa que les llistes siguin especialment útils per a tasques que impliquen afegir o eliminar elements. Les llistes proporcionen una interfície còmoda perquè els desenvolupadors gestionen i organitzin les dades, permetent operacions eficients com ara adjuntant , inserint , o esborrant elements. La capacitat d'ajustar dinàmicament la seva mida fa que les llistes siguin una eina poderosa per gestionar quantitats variables de dades en un programa.
Què són els Arrays?
Les matrius són una estructura de dades fonamental en la programació que us permet emmagatzemar una col·lecció d'elements del mateix tipus de dades en un bloc contigu de memòria. Cada element de la matriu s'identifica mitjançant un índex, que representa la seva posició. La característica clau de les matrius és que ofereixen un accés ràpid i directe als elements que utilitzen aquests índexs. Proporcionen una manera sistemàtica d'organitzar i gestionar les dades, fent-ho eficient recuperar , modificar , i manipular informació emmagatzemada a la matriu. Les matrius s'utilitzen àmpliament en diversos llenguatges de programació per la seva simplicitat i eficàcia en el maneig de conjunts ordenats de dades.
Diferència entre llistes i matrius:
| Aspecte | Arrays | Llistes |
|---|---|---|
| Mida | Les matrius tenen una mida fixa establerta durant la creació. | Les llistes són dinàmiques i poden canviar de mida durant el temps d'execució. |
| Tipus de dades | Tots els elements d'una matriu han de ser del mateix tipus de dades. | Les llistes poden acollir elements de diferents tipus de dades. |
| Assignació de memòria | La memòria per a tota la matriu s'assigna alhora durant la inicialització. | Les llistes assignen memòria dinàmicament a mesura que s'afegeixen o s'eliminen elements. |
| Hora d'accés | Les matrius proporcionen accés en temps constant als elements mitjançant la indexació. | Les llistes poden tenir un temps d'accés lleugerament variable a causa del redimensionament dinàmic. |
| Flexibilitat | Les matrius són menys flexibles, ja que la seva mida no es pot canviar fàcilment. | Les llistes són més flexibles i permeten afegir o eliminar elements fàcilment. |
| Eficiència de memòria quants zeros hi ha 1.000 milions | Pot provocar malbaratament de memòria si la mida és més gran del necessari. | Més eficient en memòria gràcies a l'assignació dinàmica. |
| Implementacions comunes | Comú en llenguatges com C/C++. | Comú en llenguatges com Python i Java. |
Implementació de llistes:
A l'exemple de codi proporcionat a Python, s'inicialitza una llista per emmagatzemar nombres enters (10, 20, 30). S'afegeixen elements, s'accedeix per índex, es modifiquen i s'eliminen. A Python, el mètode append s'utilitza per afegir i eliminar per suprimir. L'exemple mostra les operacions fonamentals de creació, modificació i gestió de llistes en aquests llenguatges de programació.
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();> >}> }> |
>
>
Python 3
# 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);> |
>
>Sortida
Elements in the vector: 10 20 30 Updated vector: 10 25>
Implementació de matrius:
En C++, C, Python, Java i JavaScript, el codi crea una matriu amb elements (10, 20, 30), accedeix i modifica elements per índex i mostra la matriu actualitzada. La sintaxi i els mètodes específics difereixen entre els idiomes, però les operacions fonamentals de matriu segueixen sent coherents, mostrant com manipular i iterar a través de matrius.
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] + ' ');> >}> >}> }> |
>
>
Python 3
# 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
generador de nombres aleatoris en c
// 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]); }> |
>
>Sortida
10 25 30>
En conclusió, les matrius ofereixen a de mida fixa , Estructura de memòria contigua amb accés eficient als elements mentre que les llistes proporcionen mida dinàmica , flexibilitat , i mètodes integrats per facilitar la manipulació. L'elecció entre ambdues depèn dels requisits específics de l'aplicació, amb matrius excel·lents en escenaris on l'accés a la memòria directa i de mida fixa són crítics, i les llistes resulten avantatjoses per a dades dinàmiques i operacions diverses. En definitiva, entendre les característiques úniques de cada estructura de dades permet als desenvolupadors prendre decisions informades en funció de les demandes de les seves tasques de programació.