Pagkatapos ng mga pag-array, ang pangalawang pinakatanyag na istraktura ng data ay Listahan ng Naka-link. Ang isang naka-link na listahan ay isang linear na istraktura ng data, na gawa sa isang kadena ng mga node kung saan ang bawat node ay naglalaman ng isang halaga at isang pointer sa susunod na node sa kadena. Sa artikulong ito, tingnan natin kung paano ipatupad ang isang naka-link na listahan sa C.
Ano ang Listahan ng Naka-link sa C?
Ang isang Listahang Naka-link ay isang istraktura ng linear na data. Ang bawat naka-link na listahan ay may dalawang bahagi, ang seksyon ng data at ang seksyon ng address na humahawak sa address ng susunod na elemento sa listahan, na tinatawag na isang node.
Ang laki ng naka-link na listahan ay hindi naayos, at ang mga item ng data ay maaaring idagdag sa anumang mga lokasyon sa listahan. Ang kawalan ay upang makapunta sa isang node, dapat tayong dumaan sa lahat ng mga paraan mula sa unang node hanggang sa node na kailangan namin. Ang Listahan ng Naka-link ay tulad ng isang array ngunit hindi katulad ng isang array, hindi ito nakaimbak nang sunud-sunod sa memorya.
Ang pinakatanyag na uri ng isang naka-link na listahan ay:
Halimbawa ng Listahan ng Naka-link
Format: [data, address]
Ulo -> [3,1000] -> [43,1001] -> [21,1002]
Sa halimbawa, ang bilang 43 ay naroroon sa lokasyon na 1000 at ang address ay naroroon sa nakaraang node. Ganito kinakatawan ang isang naka-link na listahan.
Pangunahing Pag-andar ng Listahan ng Naka-link
Mayroong maraming mga pag-andar na maaaring ipatupad sa naka-link na listahan sa C. Subukan nating maunawaan ang mga ito sa tulong ng isang halimbawa ng programa.Una, lumikha kami ng isang listahan, ipinapakita ito, isingit sa anumang lokasyon, tanggalin ang isang lokasyon. Ipapakita sa iyo ng sumusunod na code kung paano magsagawa ng mga pagpapatakbo sa listahan.
kung paano gumawa ng isang malalim na kopya sa java
#include #include void create () void display () void insert_begin () void insert_end () void insert_pos () void delete_begin () void delete_end () void delete_pos () struct node {int info struct node * next} struct node * start = NULL int main () {int choice habang (1) {printf ('n MENU n') printf ('n 1. Lumikha n') printf ('n 2. Ipakita n') printf ('n 3. Ipasok sa ang simula n ') printf (' n 4. Ipasok sa dulo n ') printf (' n 5. Ipasok sa tinukoy na posisyon n ') printf (' n 6. Tanggalin mula sa simula n ') printf (' n 7. Tanggalin mula sa dulo n ') printf (' n 8. Tanggalin mula sa tinukoy na posisyon n ') printf (' n 9.Exit n ') printf (' n ----------------- ----------------- n ') printf (' Ipasok ang iyong pinili: t ') scanf ('% d ', & pagpipilian) switch (pagpipilian) {case 1 : create () break case 2: display () break case 3: insert_begin () break case 4: insert_end () break case 5: insert_pos () break case 6: delete_begin () break case 7: delete_end () break case 8: delete_pos () break case 9: exit (0) break default: printf ('n Wrong Choice: n') break}} ibalik 0} voi d create () {struct node * temp, * ptr temp = (struct node *) malloc (sizeof (struct node)) kung (temp == NULL) {printf ('nOut of Memory Space: n') exit (0) } printf ('nEnter ang halaga ng data para sa node: t') scanf ('% d', & temp-> info) temp-> susunod = NULL kung (simulan == NULL) {start = temp} iba pa {ptr = start habang (ptr-> susunod! = NULL) {ptr = ptr-> susunod} ptr-> susunod = temp}} walang bisa na pagpapakita () {struct node * ptr if (start == NULL) {printf ('nList ay walang laman: n ') ibalik} iba pa {ptr = simulan ang printf (' nAng mga elemento ng Lista ay: n ') habang (ptr! = NULL) {printf ('% dt ', ptr-> info) ptr = ptr-> susunod}}} void insert_begin () {struct node * temp temp = (struct node *) malloc (sizeof (struct node)) kung (temp == NULL) {printf ('nOut of Memory Space: n') return} printf ('nEnter the halaga ng data para sa node: t ') scanf ('% d ', & temp-> info) temp-> susunod = NULL kung (simulan == NULL) {start = temp} iba pa {temp-> susunod = simulang simulan = temp }} void insert_end () {struct node * temp, * ptr temp = (struct node *) malloc (sizeof (struct node)) kung (temp == NULL) {printf ('nOut of Memory Space: n') return} p rintf ('nEnter ang halaga ng data para sa node: t') scanf ('% d', & temp-> info) temp-> susunod = NULL kung (simulan == NULL) {start = temp} iba pa {ptr = simulan habang (ptr-> susunod! = NULL) {ptr = ptr-> susunod} ptr-> susunod = temp}} walang bisa insert_pos () {struct node * ptr, * temp int i, pos temp = (struct node *) malloc ( sizeof (struct node)) kung (temp == NULL) {printf ('nOut of Memory Space: n') return} printf ('nEnter ang posisyon para sa bagong node upang maipasok: t') scanf ('% d' , & pos) printf ('nEnter ang halaga ng data ng node: t') scanf ('% d', & temp-> info) temp-> susunod = NULL kung (pos == 0) {temp-> susunod = simulang simulan = temp} iba pa {para (i = 0, ptr = startinext kung (ptr == NULL) {printf ('nHindi nahanap ang Posisyon: [Hawakang may pag-iingat] n') bumalik}} temp-> susunod = ptr-> susunod na ptr -> next = temp}} void delete_begin () {struct node * ptr if (ptr == NULL) {printf ('nList is Empty: n') return} else {ptr = start start = start-> susunod na printf (' nAng tinanggal na elemento ay:% dt ', ptr-> info) libre (ptr)}} void delete_end () {struct node * temp, * ptr if (start == NULL) {printf (' nList is Empty: ') exit (0) } iba pa kung (simulan-> susunod == NULL) {ptr = start start = NULL printf ('nAng tinanggal na elemento ay:% dt', ptr-> info) libre (ptr)} iba pa {ptr = magsimula habang (ptr- > susunod! = NULL) {temp = ptr ptr = ptr-> susunod} temp-> susunod = NULL printf ('nAng tinanggal na elemento ay:% dt', ptr-> info) libre (ptr)}} void delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('nAng Lista ay Walang laman: n') exit (0)} iba pa {printf ('nEnter ang posisyon ng node na tatanggalin : t ') scanf ('% d ', & pos) kung (pos == 0) {ptr = start start = start-> susunod na printf (' nAng tinanggal na elemento ay:% dt ', ptr-> info) libre (ptr )} iba pa {ptr = simulan para sa (i = 0inext kung (ptr == NULL) {printf ('nPosition Not Found: n') return}} temp-> susunod = ptr-> susunod na printf ('nAng tinanggal na elemento ay: % dt ', ptr-> info) libre (ptr)}}}Ang unang bahagi ng code na ito ay lumilikha ng isang istraktura. Ang isang naka-link na istraktura ng listahan ay nilikha upang maaari itong hawakan ang data at address kung kinakailangan namin ito. Ginagawa ito upang bigyan ang tagatala ng isang ideya kung paano dapat ang node.
struct node {int info struct node * susunod}Sa istraktura, mayroon kaming isang variable ng data na tinatawag na impormasyon upang humawak ng data at isang variable ng pointer upang ituro ang address. Mayroong iba't ibang mga pagpapatakbo na maaaring gawin sa isang naka-link na listahan, tulad ng:
- lumikha ()
- ipakita ()
- insert_begin ()
- insert_end ()
- ] insert_pos ()
- tanggalin_begin ()
- tanggalin ang ()
- tanggalin_pos ()
Ang mga pagpapaandar na ito ay tinawag ng pangunahing pagpapaandar na menu-driven. Sa pangunahing pag-andar, kumukuha kami ng input mula sa gumagamit batay sa kung anong operasyon ang nais gawin ng gumagamit sa programa. Pagkatapos ay ipinadala ang switch sa switch case at batay sa input ng gumagamit.
Batay sa kung anong input ang ibinigay na tatawagin ang pagpapaandar. Susunod, mayroon kaming iba't ibang mga pag-andar na kailangang malutas. Tingnan natin ang bawat isa sa mga pagpapaandar na ito.
Lumikha ng Pag-andar
Una, mayroong isang function na lumikha upang likhain ang naka-link na listahan. Ito ang pangunahing paraan ng paglikha ng listahan ng naka-link. Hinahayaan tayong tumingin sa code.
void create () {struct node * temp, * ptr printf ('nEnter the data value for the node: t') scanf ('% d', & temp-> info) temp-> susunod = NULL kung (simulan == NULL ) {start = temp} else {ptr = start habang (ptr-> susunod! = NULL) {ptr = ptr-> susunod} ptr-> susunod = temp}}Paglabas
isang hanay ng mga bagay na java
Una, ang dalawang mga payo ay nilikha ng uri node, ptr, at temp . Kinukuha namin ang halagang kinakailangan upang maidagdag sa naka-link na listahan mula sa gumagamit at iimbak ito sa impormasyon na bahagi ng variable ng temp at magtalaga ng susunod na iyon ay ang bahagi ng address upang maging null. Mayroong isang panimulang pointer na humahawak sa simula ng listahan. Pagkatapos ay suriin namin ang pagsisimula ng listahan. Kung ang simula ng listahan ay null, pagkatapos ay nagtatalaga kami ng temp sa start pointer. Kung hindi man, dumadaan kami sa huling punto kung saan naidagdag ang data.
Para sa mga ito, nagtatalaga kami ng ptr ng halaga ng pagsisimula at pagtawid hanggang ptr-> susunod = null . Pagkatapos ay nagtatalaga kami ptr-> susunod ang address ng temp. Sa isang katulad na paraan, may ibinigay na code para sa pagpasok sa simula, pagpasok sa dulo at pagpasok sa isang tinukoy na lokasyon.
Pag-andar sa Display
Narito ang code para sa pagpapaandar sa display.
void display () {struct node * ptr if (start == NULL) {printf ('nList ay walang laman: n') return} iba pa {ptr = start printf ('nAng mga elemento ng Lista ay: n') habang (ptr! = NULL) {printf ('% dt', ptr-> info) ptr = ptr-> susunod}}}Paglabas
Sa pagpapaandar ng display, susuriin muna namin kung ang listahan ay walang laman at ibalik kung ito ay walang laman. Sa susunod na bahagi, itatalaga namin ang simulang halaga sa ptr. Pagkatapos ay nagpapatakbo kami ng isang loop hanggang sa ptr ay null at i-print ang elemento ng data para sa bawat node, hanggang sa ang ptr ay null, na tumutukoy sa pagtatapos ng listahan.
Tanggalin ang Pag-andar
Narito ang snippet ng code upang tanggalin ang isang node mula sa naka-link na listahan.
void delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('nThe List is Empty: n') exit (0)} else {printf ('nEnter the position of the node na tatanggalin: t ') scanf ('% d ', & pos) kung (pos == 0) {ptr = start start = start-> susunod na printf (' nAng tinanggal na elemento ay:% dt ', ptr-> impormasyon ) libre (ptr)} iba pa {ptr = simulan para sa (i = 0inext kung (ptr == NULL) {printf ('nPosition Not Found: n') return}} temp-> susunod = ptr-> susunod na printf ('nThe ang tinanggal na elemento ay:% dt ', ptr-> info) libre (ptr)}}}Paglabas
Sa proseso ng pagtanggal, sinusuri muna kung walang laman ang listahan, kung oo mayroon ito. Kung hindi ito walang laman hiningi nito sa gumagamit ang posisyon na matanggal. Kapag napasok na ng gumagamit ang posisyon, sinusuri nito kung ito ang unang posisyon, kung oo nagtatalaga ito ptr upang simulan at ilipat ang panimulang pointer sa susunod na lokasyon at tatanggalin ang ptr. Kung ang posisyon ay hindi zero , pagkatapos ay nagpapatakbo ito ng isang para sa loop mula sa 0 hanggang sa pos na ipinasok ng gumagamit at nakaimbak sa pos variable. Mayroong isang kung pahayag upang magpasya kung ang posisyon na ipinasok ay hindi naroroon. Kung Ang ptr ay katumbas ng null , kung gayon wala ito.
Kami naman magtalaga ng ptr sa temp sa para sa loop, at ptr pagkatapos ay lumipat sa susunod na bahagi. Pagkatapos nito kapag natagpuan ang posisyon. Ginagawa namin ang variable ng temp upang hawakan ang halaga ng ptr-> susunod kaya nilalaktawan ang ptr. Pagkatapos ptr ay tinanggal. Katulad nito, maaari itong gawin para sa una at sa huling pagtanggal ng elemento.
Dobleng Listahan ng Naka-link
Tinawag itong listahan ng doble na naka-link dahil mayroong dalawa mga payo , isang punto sa susunod na node at iba pang mga puntos sa nakaraang node. Ang mga pagpapatakbo na isinagawa sa doble na naka-link ay pareho sa isang listahan ng iisa na naka-link. Narito ang code para sa pangunahing mga pagpapatakbo.
#include #include struct Node typedef struct Node * PtrToNode typedef PtrToNode List typedef PtrToNode Position struct Node {int e Position nakaraang Posisyon sa susunod} walang bisa Isingit (int x, List l, Posisyon p) {Posisyon TmpCell TmpCell = (struct Node *) malloc (sizeof (struct Node)) kung (TmpCell == NULL) printf ('Memory out of spacen') iba pa {TmpCell-> e = x TmpCell-> nakaraang = p TmpCell-> susunod = p-> susunod p-> susunod = TmpCell}} walang bisa ang Tanggalin (int x, List l) {Posisyon p, p1, p2 p = Hanapin (x, l) kung (p! = NULL) {p1 = p -> nakaraang p2 = p -> susunod p1 - > susunod = p -> susunod kung (p2! = NULL) // kung ang node ay hindi ang huling node p2 -> nakaraang = p -> nakaraang} iba pa printf ('Walang elemento !!! n')} walang bisa Ipakita (Listahan l) {printf ('Ang elemento ng listahan ay ::') Posisyon p = l-> susunod habang (p! = NULL) {printf ('% d ->', p-> e) p = p- > susunod}} int main () {int x, pos, ch, i List l, l1 l = (struct Node *) malloc (sizeof (struct Node)) l-> nakaraang = NULL l-> susunod = NULL List p = l printf ('DOUBLY LINKED LIST IMPLEMENTATION OF L IST ADTnn ') gawin ang {printf (' nn1. CREATEn 2. TANGGALIN 3. DISPLAYn 4. QUITnnEnter the choice :: ') scanf ('% d ', & ch) switch (ch) {case 1: p = l printf (' Ipasok ang elemento na isisingit :: ') scanf ('% d', & x) printf ('Ipasok ang posisyon ng elemento ::') scanf ('% d', & pos) para sa (i = 1 isusunod} Ipasok (x, l, p) break case 2: p = l printf ('Ipasok ang sangkap na tatanggalin ::') scanf ('% d', & x) Tanggalin (x, p) putolin ang kaso 3: Ipakita (l) masira}} habang (ch<4) } Paglabas
pagkakaiba sa pagitan ng interface at klase sa java
Kaya, tulad ng nakikita mo ang konsepto ng pagpapatakbo ay medyo simple. Ang listahan ng doble na naka-link ay may parehong operasyon tulad ng listahan ng iisa na naka-link sa wika ng C programa. Ang pagkakaiba lamang ay mayroong isa pang variable ng address kung saan ang tulong ay mas mahusay na dumadaan sa listahan sa isang dobleng listahan na naka-link.
Inaasahan kong naiintindihan mo kung paano magsagawa ng mga pangunahing operasyon sa iisa at doble na naka-link na listahan sa C.
Kung nais mong malaman ang Nakaugnay na Listahan sa Java, narito ang a .
Kung may nahahanap kang anumang mga katanungan, huwag mag-atubiling tanungin ang lahat ng iyong mga katanungan sa seksyon ng mga komento ng 'Listahan ng naka-link sa C' at ang aming koponan ay nalulugod na sagutin.