Programmēšanā saraksti un masīvi ir datu struktūras, ko izmanto datu organizēšanai un uzglabāšanai. Abiem ir savas unikālās īpašības un mērķi. Saraksti ir dinamisks un elastīgs , kas ļauj viegli mainīt izmērus izpildlaika laikā masīvi ir statisks ar fiksēts izmērs . Šī atšķirība ietekmē atmiņas lietojumu un veiktspēju.
Satura rādītājs
- Kas ir saraksti?
- Kas ir masīvi?
- Atšķirība starp sarakstiem un masīviem
- Sarakstu ieviešana
- Masīvu ieviešana
Kas ir saraksti?
Saraksti ir daudzpusīga programmēšanas datu struktūra, kas paredzēta elementu kolekcijai ar elastīgu apstrādi. dažādi datu veidi . Atšķirībā no masīviem saraksti ir dinamisks , kas nozīmē, ka to lielums programmas izpildes laikā var mainīties. Šī pielāgojamība padara sarakstus īpaši noderīgus uzdevumiem, kas saistīti ar elementu pievienošanu vai noņemšanu. Saraksti nodrošina izstrādātājiem ērtu saskarni datu pārvaldībai un organizēšanai, ļaujot veikt efektīvas darbības, piemēram, pievienojot , ievietošana , vai dzēšana elementi. Iespēja dinamiski pielāgot to lielumu padara sarakstus par spēcīgu rīku dažāda apjoma datu apstrādei programmā.
Kas ir masīvi?
Masīvi ir programmēšanas pamatdatu struktūra, kas ļauj saglabāt elementu kolekciju tāds pats datu tips blakus esošajā atmiņas blokā. Katrs masīva elements tiek identificēts ar indeksu, kas atspoguļo tā pozīciju. Masīvu galvenā iezīme ir tā, ka tie piedāvā ātru un tiešu piekļuvi elementiem, izmantojot šos indeksus. Tie nodrošina sistemātisku veidu, kā organizēt un pārvaldīt datus, padarot tos efektīvus izgūt , modificēt , un manipulēt masīvā saglabātā informācija. Masīvus plaši izmanto dažādās programmēšanas valodās to vienkāršības un efektivitātes dēļ sakārtotu datu kopu apstrādē.
Atšķirība starp sarakstiem un masīviem:
| Aspekts | Masīvi | Saraksti |
|---|---|---|
| Izmērs | Masīviem izveides laikā ir iestatīts fiksēts izmērs. | Saraksti ir dinamiski, un to lielums izpildlaikā var mainīties. |
| Datu veidi | Visiem elementiem masīvā ir jābūt tāda paša datu tipa. | Sarakstos var ievietot dažādu datu tipu elementus. |
| Atmiņas piešķiršana | Atmiņa visam masīvam tiek piešķirta uzreiz inicializācijas laikā. | Saraksti dinamiski piešķir atmiņu, kad elementi tiek pievienoti vai noņemti. |
| Piekļuves laiks | Masīvi nodrošina pastāvīgu piekļuvi elementiem, izmantojot indeksēšanu. | Sarakstiem var būt nedaudz mainīgs piekļuves laiks dinamiskas izmēru maiņas dēļ. |
| Elastīgums | Masīvi ir mazāk elastīgi, jo to lielumu nevar viegli mainīt. | Saraksti ir elastīgāki, ļaujot viegli pievienot vai noņemt elementus. |
| Atmiņas efektivitāte skaits atšķiras | Var izraisīt atmiņas zudumu, ja izmērs ir lielāks nekā nepieciešams. | Efektīvāka atmiņa, pateicoties dinamiskai piešķiršanai. |
| Kopējās ieviešanas | Izplatīts tādās valodās kā C/C++. | Izplatīts tādās valodās kā Python un Java. |
Sarakstu ieviešana:
Norādītajā Python koda piemērā saraksts tiek inicializēts, lai saglabātu veselus skaitļus (10, 20, 30). Elementi tiek pievienoti, tiem var piekļūt, izmantojot indeksu, mainīti un noņemti. Programmā Python pievienošanai tiek izmantota pievienošanas metode, bet dzēšanai - noņemšana. Piemērā ir parādītas sarakstu izveides, modificēšanas un pārvaldības pamatdarbības šajās programmēšanas valodās.
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 =>>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);> |
>
>Izvade
Elements in the vector: 10 20 30 Updated vector: 10 25>
Masīvu ieviešana:
Programmā C++, C, Python, Java un JavaScript kods izveido masīvu ar elementiem (10, 20, 30), piekļūst un modificē elementus pēc indeksa un parāda atjaunināto masīvu. Sintakse un īpašās metodes dažādās valodās atšķiras, taču galvenās masīva darbības paliek konsekventas, parādot, kā manipulēt un atkārtot, izmantojot masīvus.
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#
kartes java
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]); }> |
>
>Izvade
10 25 30>
Noslēgumā jāsaka, ka masīvi piedāvā a fiksēta izmēra , blakus esošās atmiņas struktūra ar efektīva elementu piekļuve tā kā saraksti paredz dinamiska izmēra noteikšana , elastība , un iebūvētās metodes lai atvieglotu manipulācijas. Izvēle starp abām ir atkarīga no lietojumprogrammas īpašajām prasībām, jo masīvi ir lieliski piemēroti scenārijos, kur svarīga ir fiksēta izmēra un tieša piekļuve atmiņai, un saraksti ir izdevīgi dinamiskiem datiem un dažādām darbībām. Galu galā katras datu struktūras unikālo iezīmju izpratne ļauj izstrādātājiem pieņemt apzinātus lēmumus, pamatojoties uz viņu programmēšanas uzdevumu prasībām.