Nilalaman

• Tsart ng paghahambing
• Kahulugan ng Array
• Tingnan natin ang ilan sa mga konsepto na dapat alalahanin tungkol sa mga arrays:
• Ang mga pagpapatakbo na isinagawa sa mga arrays ay:
• Halimbawa
• Kahulugan ng Listahan na Naka-link
• Ang mga operasyon na isinagawa sa Listahang naka-link ay:
• Halimbawa
• Konklusyon

Ang pangunahing pagkakaiba sa pagitan Array at Naka-link na listahan tungkol sa kanilang istraktura. Arrays ay batay sa index istruktura ng data kung saan ang bawat elemento na nauugnay sa isang index. Sa kabilang banda, ang listahan ng naka-link ay nakasalalay sa sanggunian kung saan binubuo ang bawat node ng data at mga sanggunian sa nauna at susunod na elemento.

Karaniwan, ang isang array ay isang hanay ng mga katulad na mga bagay ng data na nakaimbak sa sunud-sunod na mga lokasyon ng memorya sa ilalim ng isang karaniwang heading o isang variable na pangalan.

Habang ang isang naka-link na listahan ay isang istraktura ng data na naglalaman ng isang pagkakasunud-sunod ng mga elemento kung saan ang bawat elemento ay naka-link sa susunod na elemento. Mayroong dalawang mga patlang sa isang elemento ng naka-link na listahan. Ang isa ay ang patlang ng Data, at iba pa ay patlang ng link, ang patlang ng Data ay naglalaman ng aktwal na halaga na maiimbak at maproseso. Bukod dito, ang patlang ng link ay humahawak sa address ng susunod na item ng data sa naka-link na listahan. Ang address na ginamit upang ma-access ang isang partikular na node ay kilala bilang isang pointer.

Ang isa pang makabuluhang pagkakaiba sa pagitan ng isang hanay at naka-link na listahan ay ang Array ay may isang nakapirming laki at kinakailangang ipahayag bago, ngunit ang List List ay hindi pinigilan sa laki at palawakin at kontrata sa panahon ng pagpapatupad.

1. Tsart ng paghahambing
2. Kahulugan
3. Pangunahing Pagkakaiba
4. Konklusyon

Tsart ng paghahambing

Batayan para sa Paghahambing	Array	Naka-link na listahan
Pangunahing	Ito ay isang pare-pareho na hanay ng isang nakapirming bilang ng mga item ng data.	Ito ay isang iniutos na hanay na binubuo ng isang variable na bilang ng mga item ng data.
Laki	Tinukoy sa panahon ng pagpapahayag.	Hindi na kailangang tukuyin; lumaki at umuurit habang pinapatay.
Paglalaan ng Ilagay	Ang lokasyon ng elemento ay inilalaan sa panahon ng pag-compile.	Itinalaga ang posisyon ng elemento sa oras ng pagtakbo.
Order ng mga elemento	Sunod-sunod na naimbak	Itinapat nang random
Pag-access sa elemento	Direkta o random na na-access, i.e., Tukuyin ang index ng array o subskripsyon.	Sequentially na-access, i.e., Traverse simula sa unang node sa listahan ng pointer.
Pagsingit at pagtanggal ng elemento	Mabagal bilang pagbago ay kinakailangan.	Mas madaling, mabilis at mahusay.
Naghahanap	Binaryong paghahanap at linear na paghahanap	linear na paghahanap
Kinakailangan ang memorya	mas kaunti	Marami pa
Paggamit ng memorya	Hindi epektibo	Mahusay

Kahulugan ng Array

Ang isang array ay tinukoy bilang isang hanay ng isang tiyak na bilang ng mga homogenous na elemento o mga item ng data. Nangangahulugan ito na ang isang hanay ay maaaring maglaman ng isang uri lamang ng data, alinman sa lahat ng mga integer, lahat ng mga lumulutang na point number, o lahat ng mga character. Ang Pahayag ng isang hanay ay ang mga sumusunod:
int a;
Kung saan tinukoy ng int ang uri ng data o mga uri ng mga tindahan ng array ng mga elemento. "Isang" ay ang pangalan ng isang array, at ang bilang na tinukoy sa loob ng square bracket ay ang bilang ng mga elemento na maaaring itabi ng isang array, ito ay tinatawag ding laki o haba ng array.

Tingnan natin ang ilan sa mga konsepto na dapat alalahanin tungkol sa mga arrays:

• Ang mga indibidwal na elemento ng isang array ay maaaring ma-access sa pamamagitan ng paglalarawan ng pangalan ng array, na sinusundan ng index o subscript (pagtukoy ng lokasyon ng elemento sa array) sa loob ng square bracket. Halimbawa, upang makuha ang ika-5 elemento ng array, kailangan nating magsulat ng isang pahayag a.
• Sa anumang kaso ang mga elemento ng isang array ay maiimbak sa isang magkakasunod na lokasyon ng memorya.
• Ang pinakaunang elemento ng array ay may index zero. Nangangahulugan ito na ang una at huling elemento ay tinukoy bilang isang, at ayon sa pagkakabanggit.
• Ang bilang ng mga elemento na maaaring maiimbak sa isang array, i.e., ang laki ng isang array o haba nito ay ibinibigay ng mga sumusunod na equation:
  (itaas na nakatali-mas mababang nakatali) + 1
  Para sa nasa itaas na hanay, magiging (9-0) + 1 = 10. Kung saan 0 ay ang mas mababang gapos ng array, at 9 ang itaas na hangganan ng array.
• Maaaring mabasa o isulat sa pamamagitan ng loop ang mga arrow. Kung babasahin natin ang one-dimensional na array, nangangailangan ito ng isang loop para sa pagbabasa at iba pa para sa pagsusulat (ing) ang array, halimbawa:
  a. Para sa pagbabasa ng isang array
  para sa (i = 0; i <= 9; i ++)
  {scanf ("% d", & a); }
  b. Para sa pagsulat ng isang array
  para sa (i = 0; i <= 9; i ++)
  {f ("% d", a); }
• Sa kaso ng isang 2-D na hanay, kakailanganin nito ang dalawang mga loop at katulad na n-dimensional na array ay kakailanganing n loops.

Ang mga pagpapatakbo na isinagawa sa mga arrays ay:

1. Paglikha ng array
2. Traversing isang array
3. Pagsingit ng mga bagong elemento
4. Pagtanggal ng mga kinakailangang elemento.
5. Pagbabago ng isang elemento.
6. Pagsasama-sama ng mga arrays

Halimbawa

Ang sumusunod na programa ay naglalarawan ng pagbabasa at pagsulat ng array.

#nagsama
#nagsama
walang bisa ()
{
int a, i;
f ("Ipasok ang hanay");
para sa (i = 0; i <= 9; i ++)
{
scanf ("% d", & a);
}
f ("Ipasok ang hanay");
para sa (i = 0; i <= 9; i ++)
{
f ("% d n", a);
}
getch ();
}

Kahulugan ng Listahan na Naka-link

Ang naka-link na listahan ay isang partikular na listahan ng ilang mga elemento ng data na naka-link sa isa't isa. Sa bawat elemento ay tumuturo sa susunod na elemento na kumakatawan sa lohikal na pag-order. Ang bawat elemento ay tinatawag na isang node, na may dalawang bahagi.

INFO bahagi na nag-iimbak ng impormasyon at POINTER na tumuturo sa susunod na elemento. Tulad ng alam mo para sa pag-iimbak ng address, mayroon kaming isang natatanging mga istruktura ng data sa C na tinatawag na mga payo. Samakatuwid ang pangalawang larangan ng listahan ay dapat na isang uri ng pointer.

Ang mga uri ng mga naka-link na listahan ay listahan na naka-link na Singly, Dobleng naka-link na listahan, Listahan ng naka-link na Circular, Circular na naka-link na listahan.

Ang mga operasyon na isinagawa sa Listahang naka-link ay:

1. Paglikha
2. Traversing
3. Pagsingit
4. Pagtanggal
5. Naghahanap
6. Konklusyon
7. Ipakita

Halimbawa

Ang sumusunod na snippet ay naglalarawan ng paglikha ng isang naka-link na listahan:

istrukturang node
{
int num;
sunod-sunod na node * susunod;
}
simulan = Null;
walang likha ()
{
typedef struct node NODE;
NODE * p, * q;
pagpili ng char;
una = Null;
gawin
{
p = (NODE *) malloc (sizeof (NODE));
f ("Ipasok ang item ng data n");
scanf ("% d", & p -> num);
kung (p == Null)
{
q = magsimula;
habang (q -> susunod! = Null)
{q = q -> susunod
}
p -> susunod = q -> susunod;
q -> = p;
}
iba pa
{
p -> susunod = magsimula;
simula = p;
}
f ("Gusto mo bang magpatuloy (type y o n)? n");
scanf ("% c", at pagpipilian);
}
habang ((pagpipilian == y) || (pagpipilian == Y));
}

1. Ang isang array ay ang istraktura ng data ay naglalaman ng isang koleksyon ng mga katulad na mga elemento ng uri ng data samantalang ang listahan na naka-link ay itinuturing na non-primitive na istraktura ng data ay naglalaman ng isang koleksyon ng mga hindi nakakaugnay na mga elemento na naka-kilala bilang node.
2. Sa hanay ng mga elemento ay nabibilang sa mga index, i.e., kung nais mong makapasok sa ika-apat na elemento kailangan mong isulat ang variable na pangalan gamit ang index o lokasyon nito sa loob ng square bracket.
   Sa isang naka-link na listahan bagaman, kailangan mong magsimula mula sa ulo at magtrabaho hanggang sa makarating ka sa ika-apat na elemento.
3. Habang ang pag-access ng isang elemento ng elemento ay mabilis habang ang listahan ng naka-link ay tumatagal ng linear na oras kaya, medyo mabagal ito.
4. Ang mga pagpapatakbo tulad ng pagpasok at pagtanggal sa mga pag-install ay kumonsumo ng maraming oras. Sa kabilang banda, ang pagganap ng mga operasyon na ito sa Mga listahan na naka-link ay mabilis.
5. Ang mga arrow ay naayos na laki. Sa kaibahan, ang mga naka-link na listahan ay pabago-bago at may kakayahang umangkop at maaaring mapalawak at kinontrata ang laki nito.
6. Sa isang array, ang memorya ay itinalaga sa panahon ng pag-compile habang sa isang naka-link na listahan ito ay inilalaan sa panahon ng pagpapatupad o runtime.
7. Ang mga elemento ay naka-imbak nang sunud-sunod sa mga arrays samantalang ito ay naka-imbak nang random sa Mga listahan na naka-link.
8. Ang kinakailangan ng memorya ay hindi gaanong dahil sa aktwal na data na naka-imbak sa loob ng index sa array. Tulad ng laban, may pangangailangan para sa higit pang memorya sa Mga Listahan na Nakaugnay dahil sa pag-iimbak ng karagdagang susunod at nakaraang mga elemento ng pagtukoy.
9. Bilang karagdagan ang paggamit ng memorya ay hindi epektibo sa hanay. Sa kabaligtaran, ang paggamit ng memorya ay mahusay sa hanay.

Konklusyon

Ang mga listahan ng Array at naka-link ay ang mga uri ng mga istruktura ng data ay naiiba sa kanilang istraktura, pag-access at mga pamamaraan ng pagmamanipula, kinakailangan sa memorya at paggamit. At magkaroon ng partikular na kalamangan at kawalan sa pagpapatupad nito. Dahil dito, maaaring magamit ang alinman sa bawat pangangailangan.