సి లో లింక్డ్ లిస్ట్: సి లో లింక్డ్ లిస్ట్ ను ఎలా అమలు చేయాలి?

శ్రేణుల తరువాత, రెండవ అత్యంత ప్రజాదరణ పొందిన డేటా నిర్మాణం లింక్డ్ లిస్ట్. అనుసంధానించబడిన జాబితా ఒక సరళ డేటా నిర్మాణం, ఇది నోడ్ల గొలుసుతో తయారు చేయబడింది, దీనిలో ప్రతి నోడ్ విలువ మరియు గొలుసులోని తదుపరి నోడ్‌కు పాయింటర్ కలిగి ఉంటుంది. ఈ వ్యాసంలో, సి లో లింక్డ్ జాబితాను ఎలా అమలు చేయాలో చూద్దాం.

సి లో లింక్డ్ లిస్ట్ అంటే ఏమిటి?

లింక్డ్ జాబితా ఒక సరళ డేటా నిర్మాణం. ప్రతి లింక్ చేయబడిన జాబితాకు రెండు భాగాలు ఉన్నాయి, డేటా విభాగం మరియు జాబితాలోని తదుపరి మూలకం యొక్క చిరునామాను కలిగి ఉన్న చిరునామా విభాగం, దీనిని నోడ్ అంటారు.

లింక్ చేయబడిన జాబితా యొక్క పరిమాణం పరిష్కరించబడలేదు మరియు జాబితాలోని ఏ ప్రదేశాలలోనైనా డేటా అంశాలను జోడించవచ్చు. ప్రతికూలత ఏమిటంటే, ఒక నోడ్‌ను పొందడానికి, మొదటి నోడ్ నుండి మనకు అవసరమైన నోడ్ వరకు అన్ని మార్గాల్లో ప్రయాణించాలి. లింక్డ్ జాబితా శ్రేణి వలె ఉంటుంది, కానీ శ్రేణి వలె కాకుండా, ఇది మెమరీలో వరుసగా నిల్వ చేయబడదు.

లింక్ చేయబడిన జాబితా యొక్క అత్యంత ప్రాచుర్యం పొందిన రకాలు:

1. సింగిల్ లింక్ జాబితా
2. రెట్టింపు జాబితా జాబితా

లింక్డ్ జాబితా యొక్క ఉదాహరణ

SQL సర్వర్‌లో పైవట్ మరియు అన్‌పివోట్

ఆకృతి: [డేటా, చిరునామా]

తల -> [3,1000] -> [43,1001] -> [21,1002]

ఉదాహరణలో, 43 వ సంఖ్య స్థానం 1000 వద్ద ఉంది మరియు చిరునామా మునుపటి నోడ్‌లో ఉంది. లింక్ చేయబడిన జాబితా ఈ విధంగా ప్రాతినిధ్యం వహిస్తుంది.

ప్రాథమిక లింక్డ్ జాబితా విధులు

సి లో లింక్ చేయబడిన జాబితాలో బహుళ విధులు అమలు చేయబడతాయి. ఉదాహరణ ప్రోగ్రామ్ సహాయంతో వాటిని అర్థం చేసుకోవడానికి ప్రయత్నిద్దాం.మొదట, మేము జాబితాను సృష్టిస్తాము, దానిని ప్రదర్శిస్తాము, ఏ ప్రదేశంలోనైనా చొప్పించండి, ఒక స్థానాన్ని తొలగించండి. కింది కోడ్ జాబితాలో కార్యకలాపాలను ఎలా చేయాలో మీకు చూపుతుంది.

#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 ఎంపిక అయితే (1) {printf ('n MENU n') printf ('n 1.Create n') printf ('n 2.Display n') printf ('n 3. వద్ద చొప్పించండి ప్రారంభ n ') printf (' n 4. చివరిలో చొప్పించండి n ') printf (' n 5. పేర్కొన్న స్థానం వద్ద చొప్పించండి n ') printf (' n 6. ప్రారంభం నుండి తొలగించు n ') printf (' n 7. తొలగించు చివరి నుండి n ') printf (' n 8. పేర్కొన్న స్థానం నుండి తొలగించు n ') printf (' n 9.ఎక్సిట్ n ') printf (' n ----------------- --------------------- n ') printf (' మీ ఎంపికను నమోదు చేయండి: t ') scanf ('% d ', & ఎంపిక) స్విచ్ (ఎంపిక) {కేసు 1 . delete_pos () బ్రేక్ కేసు 9: నిష్క్రమించు (0) డిఫాల్ట్ విచ్ఛిన్నం: printf ('n తప్పు ఎంపిక: n') విచ్ఛిన్నం}} తిరిగి 0} voi d సృష్టించండి () {struct నోడ్ * టెంప్, * ptr temp = (struct node *) malloc (sizeof (struct node)) if (temp == NULL) {printf ('nOut of Memory Space: n') నిష్క్రమించు (0) } printf ('n నోడ్ కోసం డేటా విలువను నమోదు చేయండి: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} else {ptr = start (ptr-> next! = NULL) {ptr = ptr-> next} ptr-> next = temp} oid void display () {struct node * ptr if (start == NULL) {printf ('nList ఖాళీ: n ') తిరిగి} else {ptr = start printf (' n జాబితా అంశాలు: n ') అయితే (ptr! = NULL) {printf ('% dt ', ptr-> info) ptr = ptr-> next}}} void insert_begin () {struct node * temp temp = (struct node *) malloc (sizeof (struct node)) if (temp == NULL) {printf ('n మెమరీ స్థలం: n') తిరిగి} printf ('n ప్రవేశించండి నోడ్ కోసం డేటా విలువ: t ') scanf ('% d ', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} else {temp-> next = start start = temp temp} శూన్యమైన insert_end () {struct node * temp, * ptr temp = (struct node *) malloc (sizeof (struct node)) if (temp == NULL) {printf ('మెమరీ స్థలం వెలుపల: n') తిరిగి} p rintf ('n నోడ్ కోసం డేటా విలువను నమోదు చేయండి: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL) {start = temp} else {ptr = అయితే (ptr-> next! = NULL) {ptr = ptr-> next} ptr-> next = temp}} void insert_pos () {struct node * ptr, * temp int i, pos temp = (struct node *) malloc ( sizeof (struct node)) if (temp == NULL) {printf ('n మెమరీ స్థలం: n') తిరిగి} printf ('n కొత్త నోడ్ చొప్పించాల్సిన స్థానాన్ని నమోదు చేయండి: t') scanf ('% d' , & pos) printf ('n నోడ్ యొక్క డేటా విలువను నమోదు చేయండి: t') scanf ('% d', & temp-> info) temp-> next = NULL if (pos == 0) {temp-> next = start start (i = 0, ptr = startinext if (ptr == NULL) {printf ('n స్థానం కనుగొనబడలేదు: [జాగ్రత్తగా చూసుకోండి] n') తిరిగి}} temp-> next = ptr-> next ptr -> next = temp}} void delete_begin () {struct node * ptr if (ptr == NULL) {printf ('n జాబితా ఖాళీ: n') తిరిగి} else {ptr = start start = start-> next printf (' n తొలగించబడిన మూలకం:% dt ', ptr-> సమాచారం) ఉచిత (ptr)}} void delete_end () {struct node * temp, * ptr if (start == NULL) {printf (' nList is ఖాళీ: ') నిష్క్రమించు (0) } else if (start-> next == NULL) {ptr = start start = NULL printf ('n తొలగించిన మూలకం:% dt', ptr-> సమాచారం) ఉచిత (ptr)} else {ptr = అయితే (ptr- > next! = NULL) {temp = ptr ptr = ptr-> next} temp-> next = NULL printf ('n తొలగించిన మూలకం:% dt', ptr-> సమాచారం) ఉచిత (ptr)}} void delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('n జాబితా ఖాళీగా ఉంది: n') నిష్క్రమించు (0)} else {printf ('n తొలగించాల్సిన నోడ్ యొక్క స్థానాన్ని నమోదు చేయండి : t ') scanf ('% d ', & pos) if (pos == 0) {ptr = start start = start-> next printf (' n తొలగించిన మూలకం:% dt ', ptr-> సమాచారం) ఉచిత (ptr )} else {ptr = (i = 0inext if (ptr == NULL) {printf ('n స్థానం కనుగొనబడలేదు: n') తిరిగి}} temp-> next = ptr-> next printf ('n తొలగించిన మూలకం: % dt ', ptr-> సమాచారం) ఉచిత (ptr)}}}

ఈ కోడ్ యొక్క మొదటి భాగం ఒక నిర్మాణాన్ని సృష్టిస్తోంది. లింక్ చేయబడిన జాబితా నిర్మాణం సృష్టించబడుతుంది, తద్వారా ఇది మనకు అవసరమైన విధంగా డేటా మరియు చిరునామాను కలిగి ఉంటుంది. నోడ్ ఎలా ఉండాలో కంపైలర్‌కు ఒక ఆలోచన ఇవ్వడానికి ఇది జరుగుతుంది.

struct నోడ్ {int సమాచారం struct node * next}

నిర్మాణంలో, డేటాను పట్టుకోవటానికి సమాచారం అనే డేటా వేరియబుల్ మరియు చిరునామా వద్ద సూచించడానికి పాయింటర్ వేరియబుల్ ఉన్నాయి. లింక్ చేయబడిన జాబితాలో వివిధ ఆపరేషన్లు చేయవచ్చు,

• సృష్టించండి ()
• ప్రదర్శన()
• insert_begin ()
• insert_end ()
• ] insert_pos ()
• delete_begin ()
• delete_end ()
• delete_pos ()

ఈ ఫంక్షన్లను మెను నడిచే ప్రధాన ఫంక్షన్ అంటారు. ప్రధాన ఫంక్షన్‌లో, ప్రోగ్రామ్‌లో వినియోగదారు ఏ ఆపరేషన్ చేయాలనుకుంటున్నారో దాని ఆధారంగా మేము యూజర్ నుండి ఇన్‌పుట్ తీసుకుంటాము. ఇన్పుట్ అప్పుడు స్విచ్ కేసుకు పంపబడుతుంది మరియు వినియోగదారు ఇన్పుట్ ఆధారంగా.

ఏ ఇన్పుట్ అందించిన దాని ఆధారంగా ఫంక్షన్ అంటారు. తరువాత, మనకు వేర్వేరు విధులు ఉన్నాయి, అవి పరిష్కరించాల్సిన అవసరం ఉంది. ఈ ప్రతి ఫంక్షన్‌ను పరిశీలిద్దాం.

ఫంక్షన్ సృష్టించండి

మొదట, లింక్ చేయబడిన జాబితాను సృష్టించడానికి క్రియేట్ ఫంక్షన్ ఉంది. లింక్ చేయబడిన జాబితా సృష్టించబడిన ప్రాథమిక మార్గం ఇది. కోడ్‌ను చూద్దాం.

php ప్రింట్ అర్రే విలువలు మాత్రమే

void create () {struct node * temp, * ptr printf ('n నోడ్ కొరకు డేటా విలువను నమోదు చేయండి: t') scanf ('% d', & temp-> info) temp-> next = NULL if (start == NULL ) {start = temp} else {ptr = while while (ptr-> next! = NULL) {ptr = ptr-> next} ptr-> next = temp}}

అవుట్పుట్

మొదట, రకం యొక్క రెండు పాయింటర్లు సృష్టించబడతాయి నోడ్, పిటిఆర్ మరియు టెంప్ . మేము వినియోగదారు నుండి లింక్ చేయబడిన జాబితాలో చేర్చడానికి అవసరమైన విలువను తీసుకుంటాము మరియు దానిని టెంప్ వేరియబుల్ యొక్క సమాచార భాగంలో నిల్వ చేస్తాము మరియు శూన్యానికి చిరునామా భాగమైన తదుపరి టెంప్‌ను కేటాయిస్తాము. జాబితా ప్రారంభంలో ఒక ప్రారంభ పాయింటర్ ఉంది. అప్పుడు మేము జాబితా ప్రారంభానికి తనిఖీ చేస్తాము. జాబితా ప్రారంభం శూన్యమైతే, మేము ప్రారంభ పాయింటర్‌కు తాత్కాలిక నియామకం చేస్తాము. లేకపోతే, మేము డేటా జోడించబడిన చివరి స్థానానికి వెళ్తాము.

దీని కోసం, మేము ptr ప్రారంభ విలువను కేటాయించి, వరకు ప్రయాణించండి ptr-> next = null . మేము అప్పగించాము ptr-> తదుపరి తాత్కాలిక చిరునామా. ఇదే విధంగా, ప్రారంభంలో చొప్పించడానికి, చివరిలో చొప్పించడానికి మరియు పేర్కొన్న ప్రదేశంలో చొప్పించడానికి కోడ్ ఇవ్వబడింది.

ప్రదర్శన ఫంక్షన్

ప్రదర్శన ఫంక్షన్ కోసం కోడ్ ఇక్కడ ఉంది.

void display () {struct node * ptr if (start == NULL) {printf ('n జాబితా ఖాళీగా ఉంది: n') తిరిగి} else {ptr = start printf ('n జాబితా అంశాలు: n') అయితే (ptr! = NULL) {printf ('% dt', ptr-> సమాచారం) ptr = ptr-> తదుపరి}}}

అవుట్పుట్

డిస్ప్లే ఫంక్షన్లో, మేము మొదట జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేసి, అది ఖాళీగా ఉంటే తిరిగి వస్తాము. తరువాతి భాగంలో, మేము ప్రారంభ విలువను ptr కు కేటాయిస్తాము. పిటిఆర్ శూన్యమయ్యే వరకు మేము లూప్‌ను నడుపుతాము మరియు ప్రతి నోడ్‌కు డేటా ఎలిమెంట్‌ను ప్రింట్ చేస్తాము, పిటిఆర్ శూన్యమయ్యే వరకు, ఇది జాబితా ముగింపును నిర్దేశిస్తుంది.

ఫంక్షన్‌ను తొలగించండి

లింక్ చేయబడిన జాబితా నుండి నోడ్‌ను తొలగించడానికి కోడ్ యొక్క స్నిప్పెట్ ఇక్కడ ఉంది.

void delete_pos () {int i, pos struct node * temp, * ptr if (start == NULL) {printf ('n జాబితా ఖాళీగా ఉంది: n') నిష్క్రమించు (0)} else {printf ('n యొక్క స్థానాన్ని నమోదు చేయండి తొలగించాల్సిన నోడ్: t ') scanf ('% d ', & pos) if (pos == 0) {ptr = start start = start-> next printf (' n తొలగించిన మూలకం:% dt ', ptr-> సమాచారం ) ఉచిత (ptr)} else {ptr = (i = 0inext if (ptr == NULL) {printf ('n స్థానం కనుగొనబడలేదు: n') తిరిగి}} temp-> next = ptr-> next printf ('n తొలగించిన మూలకం:% dt ', ptr-> సమాచారం) ఉచిత (ptr)}}}

అవుట్పుట్

తొలగింపు ప్రక్రియలో, జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది, అవును అది ఉందా అని. ఇది ఖాళీగా లేకపోతే అది తొలగించమని వినియోగదారుని అడుగుతుంది. వినియోగదారు స్థానం లోకి ప్రవేశించిన తర్వాత, అది మొదటి స్థానం కాదా అని తనిఖీ చేస్తుంది, అవును అది కేటాయించినట్లయితే ptr ప్రారంభించడానికి మరియు ప్రారంభ పాయింటర్‌ను తదుపరి స్థానానికి తరలించి, ptr ను తొలగిస్తుంది. ఉంటే స్థానం సున్నా కాదు , అప్పుడు ఇది యూజర్ ఎంటర్ చేసిన పోస్ వరకు 0 నుండి లూప్ కోసం నడుస్తుంది pos వేరియబుల్. ఎంటర్ చేసిన స్థానం లేనట్లయితే నిర్ణయించడానికి if స్టేట్మెంట్ ఉంది. ఉంటే ptr శూన్యానికి సమానం , అప్పుడు అది లేదు.

మేము ptr ని తాత్కాలికంగా కేటాయించండి ఫర్ లూప్‌లో, మరియు పిటిఆర్ తరువాత భాగానికి వెళుతుంది. దీని తరువాత స్థానం దొరికినప్పుడు. యొక్క విలువను కలిగి ఉండటానికి మేము టెంప్ వేరియబుల్ చేస్తాము ptr-> తదుపరి అందువలన ptr ను దాటవేయడం. అప్పుడు ptr తొలగించబడుతుంది. అదేవిధంగా, ఇది మొదటి మరియు చివరి మూలకం తొలగింపు కోసం చేయవచ్చు.

రెట్టింపు లింక్డ్ జాబితా

రెండు ఉన్నందున దీనిని డబుల్ లింక్డ్ లిస్ట్ అంటారు పాయింటర్లు , తదుపరి నోడ్‌కు ఒక పాయింట్ మరియు మునుపటి నోడ్‌కు ఇతర పాయింట్లు. రెట్టింపు లింక్‌లో చేసిన ఆపరేషన్లు ఒకే లింక్డ్ లిస్ట్ మాదిరిగానే ఉంటాయి. ప్రాథమిక కార్యకలాపాల కోసం కోడ్ ఇక్కడ ఉంది.

#include #include struct Node typedef struct Node * PtrToNode typedef PtrToNode List typedef PtrToNode Position struct Node {int e స్థానం మునుపటి స్థానం తదుపరి} void చొప్పించు (int x, List l, Position p) osition స్థానం TmpCell TmpCell = (struct Node) (sizeof (struct Node)) if (TmpCell == NULL) printf ('మెమరీ అవుట్ ఆఫ్ స్పేసన్') else {TmpCell-> e = x TmpCell-> మునుపటి = p TmpCell-> next = p-> next p-> next = TmpCell}} శూన్యము తొలగించు (int x, List l) {స్థానం p, p1, p2 p = (p! = NULL) if (p, = NULL) {p1 = p -> మునుపటి p2 = p -> తదుపరి p1 - > next = p -> next if (p2! = NULL) // నోడ్ చివరి నోడ్ కాకపోతే p2 -> మునుపటి = p -> మునుపటి} else printf ('ఎలిమెంట్ ఉనికిలో లేదు !!! n')} శూన్యమైనది ప్రదర్శన (జాబితా l) {printf ('జాబితా మూలకం ::') స్థానం p = l-> తదుపరిది అయితే (p! = NULL) {printf ('% d ->', p-> e) p = p- > next}} int main () {int x, pos, ch, i List l, l1 l = (struct Node *) malloc (sizeof (struct Node)) l-> మునుపటి = NULL l-> తదుపరి = NULL జాబితా p = l printf ('డబుల్ లింక్డ్ లిస్ట్ ఇంప్లిమెంటేషన్ ఆఫ్ ఎల్ IST ADTnn ') {printf (' nn1. సృష్టించు 2. తొలగించు 3. ప్రదర్శించు 4. QUITn ఎంపికను ఎంటర్ చెయ్యండి :: ') స్కాన్ఫ్ ('% d ', & ch) స్విచ్ (ch) {కేసు 1: p = l printf (' చొప్పించాల్సిన మూలకాన్ని నమోదు చేయండి :: ') scanf ('% d', & x) printf ('మూలకం యొక్క స్థానాన్ని నమోదు చేయండి ::') స్కాన్ఫ్ ('% d', & pos) (i = 1 iతదుపరి} చొప్పించు (x, l, p) బ్రేక్ కేసు 2: p = l printf ('తొలగించాల్సిన మూలకాన్ని నమోదు చేయండి ::') scanf ('% d', & x) తొలగించు (x, p) బ్రేక్ కేసు 3: ప్రదర్శించు (l) విచ్ఛిన్నం అయితే} ch (ch<4) } 

అవుట్పుట్

మీరు పూర్ణాంకానికి డబుల్ వేయగలరా

కాబట్టి, మీరు చూడగలిగినట్లుగా కార్యకలాపాల భావన చాలా సులభం. రెట్టింపు లింక్ చేయబడిన జాబితా సి ప్రోగ్రామింగ్ భాషలో సింగిల్ లింక్డ్ లిస్ట్ మాదిరిగానే పనిచేస్తుంది. ఒకే తేడా ఏమిటంటే, రెట్టింపు లింక్ చేయబడిన జాబితాలో జాబితాను బాగా ప్రయాణించడంలో సహాయపడే మరొక చిరునామా వేరియబుల్ ఉంది.

సి లో సింగిల్ మరియు డబుల్ లింక్డ్ లిస్టులో ప్రాథమిక కార్యకలాపాలను ఎలా చేయాలో మీరు అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను.

మీరు జావాలో లింక్డ్ జాబితాను నేర్చుకోవాలనుకుంటే, ఇక్కడ a .

మీకు ఏవైనా ప్రశ్నలు వస్తే, “సి లో లింక్డ్ లిస్ట్” యొక్క వ్యాఖ్యల విభాగంలో మీ ప్రశ్నలన్నింటినీ అడగడానికి సంకోచించకండి మరియు మా బృందం సమాధానం ఇవ్వడానికి సంతోషిస్తుంది.