सरणियों के बाद, दूसरी सबसे लोकप्रिय डेटा संरचना लिंक्ड सूची है। एक लिंक की गई सूची एक रैखिक डेटा संरचना है, जो नोड्स की एक श्रृंखला से बनी होती है जिसमें प्रत्येक नोड में एक मान होता है और श्रृंखला में अगले नोड के लिए एक संकेतक होता है। इस लेख में, आइए देखें कि सी में एक लिंक्ड सूची को कैसे लागू किया जाए।
C में लिंक्ड लिस्ट क्या है?
एक लिंक्ड सूची एक रैखिक डेटा संरचना है। प्रत्येक लिंक की गई सूची में दो भाग होते हैं, डेटा खंड और पता अनुभाग जो सूची में अगले तत्व का पता रखता है, जिसे नोड कहा जाता है।
लिंक की गई सूची का आकार निश्चित नहीं है, और डेटा आइटम सूची में किसी भी स्थान पर जोड़े जा सकते हैं। नुकसान यह है कि एक नोड पर पहुंचने के लिए, हमें पहले नोड से उस नोड तक सभी तरह से पार करना होगा, जिसकी हमें आवश्यकता है। लिंक्ड सूची एक सरणी की तरह है, लेकिन एक सरणी के विपरीत, यह मेमोरी में क्रमिक रूप से संग्रहीत नहीं है।
लिंक की गई सूची के सबसे लोकप्रिय प्रकार हैं:
लिंक्ड सूची का उदाहरण
प्रारूप: [डेटा, पता]
सिर -> [3,1000] -> [४३,१००१] -> [२१,१००२]
उदाहरण में, संख्या 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 () स्ट्रक्चर नोड {int जानकारी स्ट्रक्चर नोड * अगला} स्ट्रक्चर नोड * start = NULL int main () {int choice जबकि (1) {printf ('n MENU n') प्रिंटफ ('n 1.Create n') printf ('n 2.Display n') प्रिंटफ ('n 3. 3. पर) आरम्भ एन ') प्रिंटफ (' एन 4. अंत में एन ') प्रिंटफ (' एन 5. निर्दिष्ट स्थान पर स्थित एन ') प्रिंटफ (' एन एन शुरुआत से 6.Delete) प्रिंटफ ('एन 7.Delete प्रिंट एन 'से) प्रिंटफ (' एन 8.डेलीट से निर्दिष्ट स्थिति एन ') प्रिंटफ (' एन 9. एक्सिट एन ') प्रिंटफ (' एन -----------------) --------------------- n ') प्रिंटफ (' अपनी पसंद दर्ज करें: टी ') स्कैनफ ('% डी ', और पसंद) स्विच (पसंद) {मामला 1 : create () ब्रेक केस 2: डिस्प्ले () ब्रेक केस 3: इन्सर्ट_बेगिन () ब्रेक केस 4: इन्सर्ट_एंड () ब्रेक केस 5: इन्सर्ट_पोज़ () ब्रेक केस 6: डिलीट_बिन () ब्रेक केस 7: डिलीट_एंड () ब्रेक केस 8: delete_pos () ब्रेक केस 9: एग्जिट (0) ब्रेक डिफॉल्ट: प्रिंटफ ('एन गलत चॉइस: एन') ब्रेक}} रिटर्न 0} वोई d create () {स्ट्रक्चर नोड * temp, * ptr temp = (स्ट्रक्चर नोड *) Malloc (आकार (स्ट्रक्चर नोड)) if (अस्थायी == NULL) {प्रिंटफ ('मेमोरी स्पेस का nOut: n'): निकास (0) } printf ('नोड के लिए डेटा मान को समेटें: t') scanf ('% d', और temp-> जानकारी) temp-> अगला = NULL if (start == NULL) {शुरू = temp} {ptr = start जबकि (ptr-> अगला! = NULL) {ptr = ptr-> अगला} ptr-> अगला = temp}} शून्य प्रदर्शन () {स्ट्रक्चर नोड * ptr अगर (शुरू == NULL) {प्रिंटफ ('nList खाली है: n ') वापसी} और {ptr = start printf (' nThe सूची तत्व हैं: n ') जबकि (ptr! = NULL) {प्रिंटफ ('% dt ', ptr-> जानकारी) ptr = ptr- 'अगला}}} void डालें_बेगिन () {स्ट्रक्चर नोड * अस्थायी अस्थायी = (स्ट्रक्चर नोड *) मॉलोक (आकार (स्ट्रक्चर नोड)) यदि (अस्थायी == NULL) {प्रिंटफ (O मेमोरी स्पेस का nOut: n ’) रिटर्न: प्रिंटफ (n nnnter) नोड के लिए डेटा मान: t ') scanf ('% d ', और अस्थायी-> जानकारी) अस्थायी-> अगला = NULL यदि (प्रारंभ == NULL) {प्रारंभ = अस्थायी} बाकी {temp-> अगला = प्रारंभ प्रारंभ / अस्थायी }} शून्य डालें_एंड () {स्ट्रक्चर नोड * टेम्प, * पीटीआर टेम्प = (स्ट्रक्चर नोड *) मॉलोक (आकार नोड (स्ट्रक्चर नोड)) यदि (अस्थायी == NULL) {प्रिंटफ ('मेमोरी स्पेस का nOut) n') वापसी} पी rintf ('नोड के लिए डेटा मान को समेटें: t') scanf ('% d', और अस्थायी-> जानकारी) temp-> अगला = NULL if (start == NULL) {प्रारंभ = temp} {ptr = start जबकि (ptr-> अगला! = NULL) {ptr = ptr-> अगला} ptr-> अगला = temp}} void insert_pos () {स्ट्रक्चर नोड * ptr, * temp int i, pos temp = (स्ट्रक्चर नोड *) malloc () sizeof (स्ट्रक्चर नोड)) अगर (अस्थायी == NULL) {प्रिंटफ ('मेमोरी स्पेस का nOut: n') रिटर्न} प्रिंटफ ('नए नोड में डालने के लिए स्थिति को निपटाएं: t') स्कैनफ ('% d') , और पॉज़) प्रिंटफ़ ('नोड का डेटा मान: टी') स्कैनफ़ ('% d', और अस्थायी-> जानकारी) अस्थायी-> अगला = NULL if (pos == 0) {temp- अगला = प्रारंभ प्रारंभ = temp} और {के लिए (i = 0, ptr = startinext if (ptr == NULL) {प्रिंटफ ('nPosition नहीं मिला: [देखभाल के साथ संभालें] n') वापसी}} temp-> next + ptr-> अगला ptr -> अगला = temp}} void delete_begin () {स्ट्रक्चर नोड * ptr if (ptr == NULL) {प्रिंटफ ('nList खाली है: n') वापसी} बाकी {ptr = start start => अगला printf (') n हटाए गए तत्व है:% dt ', ptr-> जानकारी) मुफ्त (ptr)}} शून्य delete_end () {स्ट्रक्चर नोड * अस्थायी, * ptr अगर (शुरू == NULL) {प्रिंटफ (' nList खाली है: ') बाहर निकलें (0) } और अगर (प्रारंभ-> अगला == NULL) {ptr = start start = NULL प्रिंटफ ('n हटाए गए तत्व है:% dt', ptr-> जानकारी) मुफ्त (ptr)} और {ptr = start जबकि (ptr-) > अगला (= NULL) {temp = ptr ptr = ptr-> अगला} temp-> अगला = NULL प्रिंटफ ('n हटाए गए तत्व है:% dt', ptr-> जानकारी) मुफ्त (ptr)} शून्य शून्य_ () {int i, pos स्ट्रक्चर नोड * temp, * ptr if (start == NULL) {Printf ('nThe लिस्ट खाली है: n') से बाहर निकलें (0)} बाकी {Printf ('नोड की स्थिति मिटाएं) : t ') स्कैनफ ('% d ', और पॉस) यदि (पॉस == 0) {ptr = start start = start-> अगला प्रिंटफ (' n हटाए गए तत्व है:% dt ', ptr-> जानकारी) मुफ्त (ptr) )} और {ptr = के लिए शुरू (i = 0inext if (ptr == NULL) {प्रिंटफ ('nPosition नहीं मिला: n') वापसी}} अस्थायी-> अगला = ptr-> अगला प्रिंटफ ('एन डिलीट एलिमेंट) है: % dt ', ptr-> जानकारी) मुफ्त (ptr)}}}इस कोड का पहला भाग एक संरचना बना रहा है। एक लिंक की गई संरचना बनाई गई है ताकि यह डेटा और पते को पकड़ सके, क्योंकि हमें इसकी आवश्यकता है। यह संकलक को यह पता लगाने के लिए किया जाता है कि नोड कैसे होना चाहिए।
संरचना नोड {int जानकारी संरचना नोड * अगला}संरचना में, हमारे पास एक डेटा वैरिएबल है जो डेटा को होल्ड करने के लिए जानकारी और एक पॉइंटर वैरिएबल है जो पते पर इंगित करता है। ऐसे विभिन्न ऑपरेशन हैं जो एक लिंक की गई सूची पर किए जा सकते हैं, जैसे:
- सृजन करना()
- प्रदर्शन ()
- डालें_बेगिन ()
- इन्सर्ट_एंड ()
- ] सम्मिलित करें
- delete_begin ()
- delete_end ()
- delete_pos ()
ये फ़ंक्शन मेनू द्वारा संचालित मुख्य फ़ंक्शन द्वारा कहे जाते हैं। मुख्य फ़ंक्शन में, हम उपयोगकर्ता से इनपुट लेते हैं कि उपयोगकर्ता प्रोग्राम में क्या ऑपरेशन करना चाहता है। इनपुट फिर स्विच केस में भेजा जाता है और उपयोगकर्ता इनपुट पर आधारित होता है।
किस इनपुट के आधार पर फ़ंक्शन को कॉल किया जाएगा। अगला, हमारे पास अलग-अलग कार्य हैं जिन्हें हल करने की आवश्यकता है। आइए इनमें से प्रत्येक कार्य पर एक नज़र डालें।
फ़ंक्शन बनाएँ
सबसे पहले, लिंक की गई सूची बनाने के लिए एक फ़ंक्शन है। यह मूल तरीका है जिससे लिंक की गई सूची बनाई गई है। हमें कोड देखें।
void create () {स्ट्रक्चर नोड * temp, * ptr printf ('नोड के लिए डेटा मान n: t') स्कैनफ ('% d', और अस्थायी-> जानकारी) temp-> अगला = NULL if (start == NULL) ) {प्रारंभ = अस्थायी} बाकी {ptr = प्रारंभ जबकि (ptr-> अगला! = NULL) {ptr = ptr-> अगला} ptr-> अगला = temp}}आउटपुट
खिड़कियों पर php की स्थापना
सबसे पहले, दो बिंदु प्रकार के बनाए जाते हैं नोड, ptr, और अस्थायी । हम उस मूल्य को लेते हैं जिसे उपयोगकर्ता से लिंक की गई सूची में जोड़ने की आवश्यकता होती है और इसे अस्थायी चर के जानकारी भाग में संग्रहीत करता है और अगले के अस्थायी को असाइन करता है जो पता भाग को अशक्त करना है। सूची की शुरुआत को पकड़े हुए एक स्टार्ट पॉइंटर है। फिर हम सूची की शुरुआत के लिए जांच करते हैं। यदि सूची की शुरुआत शून्य है, तो हम प्रारंभ सूचक को अस्थायी असाइन करते हैं। अन्यथा, हम अंतिम बिंदु पर पहुंच जाते हैं, जहां डेटा जोड़ा गया है।
इसके लिए, हम ptr को स्टार्ट वैल्यू और traverse तक असाइन करते हैं पीटीआर-> अगला = अशक्त । हम तो असाइन करते हैं पीटीआर-> अगला अस्थायी का पता। इसी तरह, शुरुआत में डालने, अंत में डालने और एक निर्दिष्ट स्थान पर डालने के लिए कोड दिया गया है।
प्रदर्शन समारोह
यहाँ प्रदर्शन समारोह के लिए कोड है।
void डिस्प्ले () {स्ट्रक्चर नोड * ptr if (start == NULL) {प्रिंटफ ('nList खाली है: n') वापसी} और {ptr = start printf ('nThe लिस्ट एलिमेंट्स हैं: n') जबकि (ptr! = NULL) {प्रिंटफ ('% dt', ptr-> जानकारी) ptr = ptr-> अगला}}}आउटपुट
प्रदर्शन फ़ंक्शन में, हम पहले जाँचते हैं कि सूची खाली है या नहीं और यदि खाली है तो वापस लौटें। अगले भाग में, हम ptr को आरंभिक मूल्य प्रदान करते हैं। हम तब तक एक लूप चलाते हैं जब तक कि ptr शून्य है और प्रत्येक नोड के लिए डेटा तत्व को प्रिंट नहीं करता है, जब तक कि ptr शून्य है, जो सूची के अंत को निर्दिष्ट करता है।
फ़ंक्शन हटाएं
लिंक की गई सूची से नोड हटाने के लिए यहां कोड का स्निपेट है।
void delete_pos () {int i, pos संरचना नोड * temp, * ptr if (start == NULL) {Printf ('nThe सूची खाली है: n') बाहर निकलें (0)} और {printf ('nnnter) की स्थिति हटाए जाने वाले नोड: t ') स्कैनफ ('% d ', और पॉस) यदि (पॉस == 0) {ptr = start start = start-> अगला प्रिंटफ (' n हटाए गए तत्व है:% dt ', ptr-> जानकारी ) मुक्त (ptr)} और {ptr = के लिए शुरू (i = 0inext if (ptr == NULL) {प्रिंटफ ('nPosition नहीं मिला: n') वापसी}} temp-> अगला = ptr- अगला प्रिंटफ ('nThe) हटाया गया तत्व है:% dt ', ptr-> जानकारी) मुफ्त (ptr)}}}आउटपुट
विलोपन प्रक्रिया में, यह पहले जाँचता है कि सूची खाली है, यदि हाँ यह मौजूद है। यदि यह खाली नहीं है, तो यह उपयोगकर्ता को हटाए जाने की स्थिति के लिए पूछता है। एक बार जब उपयोगकर्ता स्थिति में प्रवेश करता है, तो यह जांचता है कि क्या यह पहली स्थिति है, यदि हाँ यह असाइन करता है पीटीआर स्टार्ट पॉइंटर को अगले स्थान पर लाने और ले जाने के लिए और ptr को हटाता है। अगर द स्थिति शून्य नहीं है , तो यह उपयोगकर्ता द्वारा दर्ज किए गए पॉस के लिए सभी तरह से 0 से लूप के लिए चलता है और इसमें संग्रहीत होता है स्थिति परिवर्तनशील। यदि दर्ज की गई स्थिति मौजूद नहीं है, तो यह तय करने के लिए कि क्या बयान है। अगर पीटीआर शून्य के बराबर है , तो यह मौजूद नहीं है।
हम अस्थायी करने के लिए ptr असाइन करें लूप के लिए, और ptr फिर अगले भाग पर जाता है। इसके बाद जब पोजिशन मिल जाती है। हम का मान रखने के लिए अस्थायी चर बनाते हैं पीटीआर-> अगला इस प्रकार ptr को छोड़ देना चाहिए। फिर ptr को हटा दिया जाता है। इसी तरह, यह पहले और अंतिम तत्व के विलोपन के लिए किया जा सकता है।
संदेह से जुड़ी सूची
इसे दोगुनी लिंक की गई सूची कहा जाता है क्योंकि दो हैं संकेत करने वाला , अगले नोड के लिए एक बिंदु और पिछले नोड के लिए अन्य बिंदु। दोगुने लिंक में किए गए ऑपरेशन एकल लिंक की गई सूची के समान हैं। यहाँ बुनियादी कार्यों के लिए कोड है।
#include #include स्ट्रक्चर नोड नोड टाइपिडेफ स्ट्रक्चर नोड * PtrToNode typedef PtrToNode सूची टाइप किया हुआ PtrToNode स्थिति ढांचा नोड {इंट ई स्थिति पिछला स्थान अगला} vos सम्मिलित करें (int x, List l, स्थिति p) {स्थिति TmpCell TmpCell = (ढांचा नोड * मॉल) (sizeof (स्ट्रक्चर नोड)) अगर (TmpCell == NULL) प्रिंटफ ('मेमोरी आउट ऑफ स्पेस') बाकी {TmpCell-> e = x TmpCell-> पिछला = p TmpCell-> अगला = p-> अगला p-> अगला = TmpCell}} शून्य हटाएं (int x, List l) {स्थिति p, p1, P2 p = Find (x, l) if (p! = NULL) {p1 = p -> पिछला P2 = p -> अगला 11! > अगला = p -> अगला अगर (P2! = NULL) // अगर नोड अंतिम नोड नहीं है P2 -> पिछले = p -> पिछले} और प्रिंटफ ('तत्व मौजूद नहीं है !!! n')} शून्य! प्रदर्शन (सूची l) {प्रिंटफ ('सूची तत्व हैं ::') स्थिति p = l-> अगली बार (पी! = NULL) {प्रिंटफ ('% d ->', p-> ई) p = p- > अगला}} int main () {int x, pos, ch, i List l, l1 l = (स्ट्रक्चर नोड) * Malloc (sizeof (स्ट्रक्चर नोड)) l-> पिछला = NULL l-> अगला = NULL लिस्ट p = l प्रिंटफ ('L से पूरी तरह से जुड़ा हुआ लिंक IST ADTnn ') do {printf (' nn1) CREATEn 2. DELETEn 3. DISPLAYn 4. पसंद को पूरा करें :: ') scanf ('% d ', और ch) स्विच (ch) {केस 1: p = l प्रिंटफ (' डालने के लिए तत्व डालें :: ') scanf ('% d', & x) प्रिंटफ़ ('तत्व की स्थिति दर्ज करें ::') स्कैनफ़ ('% d', और पॉज़) के लिए (i = 1 i)अगला} डालें (x, l, p) ब्रेक केस 2: p = l प्रिंटफ ('डिलीट किए जाने वाला तत्व डालें ::') स्कैनफ ('% d', और x) डिलीट (x, p) ब्रेक केस 3: डिस्प्ले (l) ब्रेक}} जबकि (ch)<4) } आउटपुट
sql में दिनांक डेटा प्रकार
इसलिए, जैसा कि आप देख सकते हैं कि संचालन की अवधारणा काफी सरल है। दोगुनी लिंक की गई सूची में वही कार्य हैं जो सी प्रोग्रामिंग भाषा में एकल लिंक की गई सूची के समान हैं। एकमात्र अंतर यह है कि एक और पता चर है जो मदद करता है सूची को दोगुनी लिंक की गई सूची में बेहतर तरीके से खोज रहा है।
मुझे आशा है कि आप समझ गए होंगे कि सी में एकल और दोगुनी लिंक वाली सूची पर बुनियादी संचालन कैसे करें।
यदि आप जावा में लिंक्ड सूची सीखना चाहते हैं, तो यहाँ है ।
यदि आपको कोई प्रश्न आता है, तो 'सी में लिस्टेड लिस्ट सी' में अपने सभी प्रश्न पूछने के लिए स्वतंत्र महसूस करें और हमारी टीम जवाब देने में प्रसन्न होगी।