Pēc masīviem otra populārākā datu struktūra ir Linked List. Saistītais saraksts ir lineāra datu struktūra, kas veidota no mezglu ķēdes, kurā katrs mezgls satur vērtību un rādītāju uz nākamo ķēdes mezglu. Šajā rakstā redzēsim, kā ieviest saistīto sarakstu C.
klases __init__ pitons
Kas ir sasaistītais saraksts C?
Saistītais saraksts ir lineāra datu struktūra. Katram saistītajam sarakstam ir divas daļas, datu sadaļa un adreses sadaļa, kurā ir saraksta nākamā elementa adrese, ko sauc par mezglu.
Saistītā saraksta lielums nav noteikts, un datu vienumus var pievienot jebkurā saraksta vietā. Trūkums ir tāds, ka, lai nokļūtu mezglā, mums ir jāiet pāri visam ceļam no pirmā mezgla līdz vajadzīgajam mezglam. Saistītais saraksts ir kā masīvs, bet atšķirībā no masīva tas netiek secīgi saglabāts atmiņā.
Vispopulārākie saistītā saraksta veidi ir:
Saistītā saraksta piemērs
Formāts: [dati, adrese]
Galva -> [3,1000] -> [43,1001] -> [21,1002]
Šajā piemērā skaitlis 43 atrodas 1000. vietā un adrese atrodas iepriekšējā mezglā. Šādi tiek attēlots saistīts saraksts.
Saistītā saraksta pamatfunkcijas
Saistītajā sarakstā C. ir vairākas funkcijas, kuras var ieviest. Mēģināsim tās saprast ar programmas parauga palīdzību.Pirmkārt, mēs izveidojam sarakstu, parādām to, ievietojam jebkurā vietā, izdzēšam vietu. Šis kods parādīs, kā veikt darbības sarakstā.
#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} struktūras mezgls * sākums = NULL int main () {int choice while (1) {printf ('n MENU n') printf ('n 1.Create n') printf ('n 2.Display n') printf ('n 3.Ievietot sākums n ') printf (' n 4.Ievietojiet beigās n ') printf (' n 5.Ievietojiet norādītajā vietā n ') printf (' n 6.Dzēst no sākuma n ') printf (' n 7.Dzēst no beigām n ') printf (' n 8. Dzēst no norādītās pozīcijas n ') printf (' n 9. Exit n ') printf (' n ----------------- --------------------- n ') printf (' Ievadiet savu izvēli: t ') scanf ('% d 'un izvēle) slēdzis (izvēle) {gadījums 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}} return 0} voi d izveidot () {struktūras mezgls * temp, * ptr temp = (struktūras mezgls *) malloc (sizeof (struktūras mezgls)) if (temp == NULL) {printf ('nOut of Memory Space: n') iziet (0) } printf ('nIevadiet mezgla datu vērtību: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} else {ptr = start while (ptr-> next! = NULL) {ptr = ptr-> next} ptr-> next = temp}} anulēt displeju () {struct mezgls * ptr if (start == NULL) {printf ('nList ir tukšs: n ') return} else {ptr = start printf (' nSaraksta elementi ir: n '), savukārt (ptr! = NULL) {printf ('% dt ', ptr-> info) ptr = ptr-> next}}} void insert_begin () {struktūras mezgls * temp temp = (struktūras mezgls *) malloc (sizeof (struktūras mezgls)) if (temp == NULL) {printf ('nOut of Memory Space: n') return} printf ('nIevadiet datu vērtība mezglam: t ') scanf ('% d ', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} else {temp-> next = start start = temp }} void insert_end () {struktūras mezgls * temp, * ptr temp = (struktūras mezgls *) malloc (sizeof (struktūras mezgls)) if (temp == NULL) {printf ('nNo atmiņas vietas: n') atgriešanās} lpp rintf ('nIevadiet mezgla datu vērtību: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} else {ptr = start while (ptr-> next! = NULL) {ptr = ptr-> next} ptr-> next = temp}} void insert_pos () {struct node * ptr, * temp int i, pos temp = (struct node *) malloc ( sizeof (struktūras mezgls)) if (temp == NULL) {printf ('nNo atmiņas vietas: n') return} printf ('nIevadiet ievietojamā jaunā mezgla pozīciju: t') scanf ('% d' , & pos) printf ('nIevadiet mezgla datu vērtību: t') scanf ('% d', & temp-> info) temp-> next = NULL if (pos == 0) {temp-> next = start start = temp} else {for (i = 0, ptr = startinext if (ptr == NULL) {printf ('nPozīcija nav atrasta: [Rīkojieties uzmanīgi] n') atgriešanās}} temp-> next = ptr-> next ptr -> next = temp}} void delete_begin () {struct mezgls * ptr if (ptr == NULL) {printf ('nList is Empty: n') return} else {ptr = start start = start-> next printf (' n Dzēstais elements ir:% dt ', ptr-> info) bezmaksas (ptr)}} void delete_end () {struct mezgls * temp, * ptr if (start == NULL) {printf (' nList is Empty: ') izeja (0) } else if (start-> next == NULL) {ptr = start start = NULL printf ('n Dzēstais elements ir:% dt', ptr-> info) bezmaksas (ptr)} else {ptr = start while (ptr- > next! = NULL) {temp = ptr ptr = ptr-> next} temp-> next = NULL printf ('n Dzēstais elements ir:% dt', ptr-> info) bezmaksas (ptr)}} void delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('nSaraksts ir tukšs: n') exit (0)} else {printf ('nIevadiet dzēšamā mezgla pozīciju : t ') scanf ('% d ', & pos) if (pos == 0) {ptr = start start = start-> next printf (' n Dzēstais elements ir:% dt ', ptr-> info) bezmaksas (ptr )} else {ptr = start for (i = 0inext if (ptr == NULL) {printf ('nPosition not Found: n') return}} temp-> next = ptr-> next printf ('n Dzēstais elements ir: % dt ', ptr-> info) bezmaksas (ptr)}}}Šī koda pirmā daļa ir struktūras izveide. Saistītā saraksta struktūra tiek izveidota tā, lai tajā varētu glabāt datus un adresi pēc nepieciešamības. Tas tiek darīts, lai kompilatoram dotu priekšstatu par to, kādam jābūt mezglam.
struct mezgls {int info struct mezgls * nākamais}Struktūrā mums ir datu mainīgais, ko sauc par info, lai saglabātu datus, un rādītāja mainīgais, kas norāda uz adresi. Saistītajā sarakstā var veikt dažādas darbības, piemēram:
- izveidot ()
- displejs ()
- insert_begin ()
- ievietot_beigt ()
- ] insert_pos ()
- dzēst_sākt ()
- dzēst_beigt ()
- delete_pos ()
Šīs funkcijas izsauc ar izvēlni balstītā galvenā funkcija. Galvenajā funkcijā mēs ņemam lietotāja ievadi, pamatojoties uz to, kādu darbību lietotājs vēlas veikt programmā. Pēc tam ievade tiek nosūtīta uz slēdža lietu un balstīta uz lietotāja ievadi.
kā pārveidot par bināru pitonā
Pamatojoties uz ievadīto informāciju, funkcija tiks izsaukta. Tālāk mums ir dažādas funkcijas, kuras jāatrisina. Apskatīsim katru no šīm funkcijām.
Izveidot funkciju
Pirmkārt, ir izveidota funkcija, lai izveidotu saistīto sarakstu. Tas ir galvenais veids, kā tiek izveidots saistīts saraksts. Ļauj mums apskatīt kodu.
void create () {struct mezgls * temp, * ptr printf ('nIevadiet mezgla datu vērtību: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL ) {start = temp} else {ptr = start while (ptr-> next! = NULL) {ptr = ptr-> next} ptr-> next = temp}}Rezultāts
Pirmkārt, tiek izveidoti divi šāda veida rādītāji mezgls, ptr un temp . Mēs no lietotāja paņemam vērtību, kas jāpievieno saistītajā sarakstā, un glabājam to temp mainīgā informācijas daļā un piešķiram temp nākamajai, kas ir adreses daļa, null. Ir sākuma rādītājs, kas tur saraksta sākumu. Tad mēs pārbaudām saraksta sākumu. Ja saraksta sākums nav derīgs, sākuma rādītājam mēs piešķiram temp. Pretējā gadījumā mēs šķērsojam pēdējo punktu, kur dati ir pievienoti.
Šim nolūkam mēs piešķiram ptr sākuma vērtību un šķērso līdz ptr-> next = null . Pēc tam mēs piešķiram ptr-> nākamais temp adrese Līdzīgā veidā ir dots kods ievietošanai sākumā, ievietošanai beigās un ievietošanai noteiktā vietā.
Displeja funkcija
Šis ir displeja funkcijas kods.
void display () {struct mezgls * ptr if (start == NULL) {printf ('nList is empty: n') return} else {ptr = start printf ('nSaraksta elementi ir: n'), kamēr (ptr! = NULL) {printf ('% dt', ptr-> info) ptr = ptr-> nākamais}}}Rezultāts
Displeja funkcijā mēs vispirms pārbaudām, vai saraksts ir tukšs, un atgriežamies, ja tas ir tukšs. Nākamajā daļā mēs piešķiram sākuma vērtību ptr. Pēc tam mēs palaižam cilpu, līdz ptr ir nulle, un izdrukājam katra mezgla datu elementu, līdz ptr ir nulle, kas norāda saraksta beigas.
Dzēst funkciju
Šeit ir koda fragments, lai dzēstu mezglu no saistītā saraksta.
void delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('nSaraksts ir tukšs: n') iziet (0)} else {printf ('nIevadiet dzēšamais mezgls: t ') scanf ('% d ', & pos) if (pos == 0) {ptr = start start = start-> next printf (' n Dzēstais elements ir:% dt ', ptr-> info ) free (ptr)} else {ptr = start for (i = 0inext if (ptr == NULL) {printf ('nPosition not Found: n') return}} temp-> next = ptr-> next printf ('nThe dzēstais elements ir:% dt ', ptr-> info) bezmaksas (ptr)}}}Rezultāts
Dzēšanas procesā vispirms pārbauda, vai saraksts ir tukšs, ja jā, tas pastāv. Ja tas nav tukšs, tas prasa lietotājam izdzēst pozīciju. Kad lietotājs ir ievadījis pozīciju, viņš pārbauda, vai tā ir pirmā pozīcija, ja jā, tā piešķir ptr lai sāktu un pārvietotu sākuma rādītāju uz nākamo vietu un izdzēstu ptr. Ja pozīcija nav nulle , tad tas darbojas for for loop no 0 līdz pat lietotāja ievadītajai pozīcijai un saglabāts poz mainīgais. Ir paziņojums if, lai izlemtu, vai ievadītā pozīcija nav. Ja ptr ir vienāds ar nulli , tad tā nav.
Mēs piešķirt ptr temp for ciklā un ptr pēc tam pāriet uz nākamo daļu. Pēc tam, kad tiek atrasta pozīcija. Mēs izveidojam temp mainīgo, lai noturētu vērtību ptr-> nākamais tādējādi izlaižot ptr. Pēc tam ptr tiek dzēsts. Līdzīgi to var izdarīt pirmā un pēdējā elementa dzēšanai.
Apšaubāmi saistīts saraksts
To sauc par divkārši saistīto sarakstu, jo ir divi norādes , viens punkts uz nākamo mezglu un citi punkti uz iepriekšējo mezglu. Darbības, kas veiktas divkāršā sasaistē, ir līdzīgas tām, kas veiktas atsevišķi saistītā sarakstā. Šis ir pamatdarbību kods.
#include #include struct Mezgls typedef struct Mezgls * PtrToNode typedef PtrToNode Saraksts typedef PtrToNode Pozīcijas struktūras mezgls {int e Pozīcija iepriekšējā pozīcija nākamā} void Insert (int x, List l, Position p) {Position TmpCell TmpCell = (struct Node *) malloc (sizeof (struct Node)) if (TmpCell == NULL) printf ('Atmiņā nav vietas') cits {TmpCell-> e = x TmpCell-> iepriekšējais = p TmpCell-> next = p-> next p-> next = TmpCell}} anulēt Dzēst (int x, L saraksts) {Pozīcija p, p1, p2 p = Atrast (x, l) if (p! = NULL) {p1 = p -> iepriekšējā p2 = p -> nākamā p1 - > nākamais = p -> nākamais, ja (p2! = NULL) // ja mezgls nav pēdējais mezgls p2 -> iepriekšējais = p -> iepriekšējais} cits printf ('Elements neeksistē !!! n')} spēkā neesošs Displejs (l saraksts) {printf ('Saraksta elements ir ::') Pozīcija p = l-> nākamā, kamēr (p! = NULL) {printf ('% d ->', p-> e) p = p- > nākamais}} int main () {int x, pos, ch, i Saraksts l, l1 l = (struktūras mezgls *) malloc (sizeof (struktūras mezgls)) l-> iepriekšējais = NULL l-> nākamais = NULL saraksts p = l printf ('DUBULI SAISTĪTĀ SARAKSTA L IST ADTnn ') do {printf (' nn1. CREATEn 2. DELETEn 3. DISPLAYn 4. QUITnnIevadiet izvēles :: ') scanf ('% d ', & ch) slēdzi (ch) {gadījums 1: p = l printf (' Ievadiet ievietojamo elementu :: ') scanf ('% d', & x) printf ('Ievadiet elementa pozīciju ::') scanf ('% d', & pos) priekš (i = 1 inākamais} Ievietot (x, l, p) 2. pārtraukuma gadījumu: p = l printf ('Ievadiet dzēšamo elementu ::') scanf ('% d', & x) Dzēst (x, p) 3. pārtraukuma gadījums: displejs (l) pārtraukums}}, kamēr (ch<4) } Rezultāts
veidi, kā izveidot singleton klasi java
Tātad, kā redzat, operāciju jēdziens ir diezgan vienkāršs. Divreiz saistītajam sarakstam ir tādas pašas darbības kā atsevišķi saistītam sarakstam C programmēšanas valodā. Vienīgā atšķirība ir tā, ka ir vēl viens adreses mainīgais, kas palīdz labāk šķērsot sarakstu divkārši saistītā sarakstā.
Es ceru, ka jūs esat sapratuši, kā veikt pamata darbības atsevišķā un divkārši saistītā C sarakstā.
Ja vēlaties apgūt saistīto sarakstu Java, šeit ir norādīts .
Ja rodas kādi jautājumi, droši uzdodiet visus jautājumus komentāru sadaļā “Saistītais saraksts C”, un mūsu komanda ar prieku atbildēs.