यह दृष्टिकोण विफलता के लिए अभिशप्त है और आमतौर पर शुरुआत से पुनर्लेखन की आवश्यकता होती है।
इसलिए, इस परिदृश्य को हल करने के लिए, हम समस्या को कई उप-समस्याओं में विभाजित करने का प्रयास कर सकते हैं और फिर इसे एक-एक करके हल करने का प्रयास कर सकते हैं। एक।
यह न केवल हमारे कार्य को आसान बनाता है, बल्कि हमें उच्च स्तर से अब बड़ा सवाल यह है कि सैद्धांतिक रूप से नहीं, बल्कि सॉफ़्टवेयर को "ब्रेक" कैसे किया जाए। हम लोकप्रिय भाषाओं में कई अलग-अलग प्रकार की ऐसी इकाइयाँ देखेंगे - जैसे C / C++, पायथन और amp; जावा। उदाहरण के लिए, मान लें कि हमारे पास एक प्रोग्राम में सभी बुनियादी लिंक्ड लिस्ट इंसर्ट हैं। चूंकि कई विधियाँ (फ़ंक्शन) हैं, हम आवश्यक मुख्य फ़ंक्शन के ऊपर सभी विधि परिभाषाएँ लिखकर प्रोग्राम को अव्यवस्थित नहीं कर सकते। लेकिन अगर हमने किया भी, तो ऑर्डर करने के तरीकों की समस्या हो सकती है, जब एक विधि दूसरे से पहले होनी चाहिए, और इसी तरह। इसलिए, इस समस्या को हल करने के लिए, हम शुरुआत में सभी प्रोटोटाइप घोषित कर सकते हैं। कार्यक्रम, और फिर मुख्य विधि और उसके नीचे हम उन्हें किसी विशेष क्रम में परिभाषित कर सकते हैं: कार्यक्रम: C / C++ पर जाएं
< a href = # Python> Python पर जाएं
Java पर जाएं
C / C++
// एक पूरी लिंक की गई सूची डालें
# include "stdio.h >
# include "stdlib.h >
// ------------ -------------- ------ कोड>
<कोड वर्ग = "टिप्पणियां"> // घोषणाएं - प्रारंभ करें: कोड>
<कोड वर्ग = "टिप्पणियां"> // ------ -------------------------- कोड>
<कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड;
स्ट्रक्चर
Node * create_node (
int कोड> <कोड वर्ग = "सादा"> डेटा);
<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य कोड> <कोड वर्ग = "सादा"> b_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> डेटा);
<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य कोड> <कोड वर्ग = "सादा"> n_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> डेटा, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> स्थिति);
<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य कोड> <कोड वर्ग = "सादा"> e_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> डेटा);
<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य कोड> <कोड वर्ग = "सादा"> प्रदर्शन ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड * अस्थायी);
// ------------ -------------- ------ कोड>
<कोड वर्ग = "टिप्पणियां"> // घोषणाएं - अंत: कोड>
<कोड वर्ग = "टिप्पणियां"> // ------ -------------------------- कोड>
<कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> मुख्य () कोड>
<कोड वर्ग = "सादा"> {
<कोड वर्ग = "कीवर्ड बोल्ड"> स्ट्रक्चर कोड> <कोड क्लास = "प्लेन"> नोड * हेड = न्यूल;
int
ch, data, pos;
printf
(
" लिंक की गई सूची: "
<कोड वर्ग ="सादा">);
जबकि
(1) {
प्रिंटफ कोड> <कोड क्लास = "प्लेन"> (कोड> <कोड क्लास = "स्ट्रिंग"> "1.इन्सर्ट एट बिगिनिंग" कोड> <कोड क्लास = "प्लेन ">);
प्रिंटफ
(
"2.Insert नौवें स्थान पर" कोड> <कोड वर्ग = "सादा">);
printf
(
"3.Insert समाप्त होने पर"
<कोड वर्ग = "सादा">);
printf
(
"4.Display " कोड> <कोड वर्ग = "सादा">);
printf
(
"0.Exit " कोड> <कोड वर्ग = "सादा">);
printf
(
"अपनी पसंद दर्ज करें :" कोड> <कोड वर्ग = "सादा">);
scanf
(
"% d" कोड> <कोड वर्ग = "सादा">, और amp; ch);
स्विच
(ch) {
<कोड वर्ग ="अपरिभाषित रिक्त स्थान"> कोड> <कोड वर्ग ="कीवर्ड बोल्ड"> केस कोड> <कोड वर्ग ="सादा "> 1: कोड>
< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> कोड> <कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "स्ट्रिंग"> "दर्ज करें डेटा:" कोड> <कोड वर्ग = "सादा">);
scanf
(
"% d" कोड> <कोड वर्ग = "सादा">, और amp; डेटा);
<कोड वर्ग = "सादा"> b_insert (& amp; सिर, डेटा);
ब्रेक
;
केस
2:
< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> कोड> <कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "स्ट्रिंग"> "दर्ज करें डेटा:" कोड> <कोड वर्ग = "सादा">);
scanf
(
"% d" कोड> <कोड वर्ग = "सादा">, और amp; डेटा);
printf
(
" स्थिति दर्ज करें: "
);
scanf
(
"% d" कोड> <कोड वर्ग = "सादा">, और amp; स्थिति);
<कोड वर्ग = "सादा"> n_insert (& amp; सिर, डेटा, स्थिति);
ब्रेक
;
केस
3:
< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> कोड> <कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "स्ट्रिंग"> "दर्ज करें डेटा:" कोड> <कोड वर्ग = "सादा">);
scanf
(
"% d" कोड> <कोड वर्ग = "सादा">, और amp; डेटा);
<कोड वर्ग = "सादा"> e_insert (& amp; सिर, डेटा);
ब्रेक
;
केस
4:
< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> कोड> <कोड वर्ग = "सादा"> प्रदर्शन (सिर);
ब्रेक
;
केस
0:
< कोड वर्ग = "अपरिभाषित रिक्त स्थान"> कोड> <कोड वर्ग =" कीवर्ड बोल्ड "> वापसी कोड> <कोड वर्ग = "सादा"> 0;
डिफ़ॉल्ट
:
कोड> <कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "स्ट्रिंग"> "गलत विकल्प" कोड> <कोड वर्ग = "सादा">);
}
}
<कोड वर्ग ="सादा ">} कोड>
<कोड वर्ग = "टिप्पणियां"> // ---------------- ---------- ------ // परिभाषाएँ - START:
// ---- ---------------------------- कोड>
<कोड क्लास = "कीवर्ड बोल्ड"> स्ट्रक्चर कोड> <कोड क्लास = "प्लेन"> नोड {कोड>
<कोड क्लास = "कलर 1 बोल्ड"> इंट कोड> < कोड वर्ग = "सादा"> डेटा;
<कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड * अगला;
<कोड वर्ग = "सादा">};
struct
Node * create_node (
int
data)
{
< कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड * अस्थायी कोड>
<कोड वर्ग = "सादा"> = ( कोड> < कोड क्लास = "कीवर्ड बोल्ड"> स्ट्रक्चर कोड> <कोड क्लास = "प्लेन"> नोड *) कोड>
<कोड क्लास = "फंक्शन बोल्ड"> मॉलोक कोड> < कोड वर्ग = "सादा"> (कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> आकार कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड));
<कोड वर्ग = "सादा"> अस्थायी- > डेटा = डेटा;
<कोड वर्ग = "सादा"> अस्थायी- > अगला = शून्य;
रिटर्न
temp;
}
void
b_insert ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड "> int
data)
{
कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड * new_node = create_node (डेटा);
new_node- > अगला = * सिर;
<कोड वर्ग = "सादा"> * सिर = new_node;
}
void
n_insert ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड "> int
data,
int
pos)
{
if
(* सिर == NULL) {
<कोड वर्ग = "सादा"> b_insert (सिर, डेटा);
<कोड वर्ग = "कीवर्ड बोल्ड"> वापसी <कोड वर्ग = "सादा">;
}
स्ट्रक्चर कोड> <कोड क्लास =" प्लेन "> नोड * new_node = create_node (डेटा);
स्ट्रक्चर
Node * temp = * head;
के लिए
(
int
i = 0; i "pos - 2;++ i)
temp = अस्थायी- > अगला;
new_node- > अगला = अस्थायी- > अगला;
<कोड वर्ग = "सादा"> अस्थायी- > अगला = नया_नोड;
}
void
e_insert ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड "> int
data)
{
कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> अगर कोड> <कोड वर्ग = "सादा"> (* सिर == नल) {
<कोड वर्ग = "सादा"> b_insert (सिर, डेटा);
<कोड वर्ग = "कीवर्ड बोल्ड"> वापसी <कोड वर्ग = "सादा">;
}
स्ट्रक्चर कोड> <कोड क्लास =" प्लेन "> नोड * टेम्प = * हेड;
जबकि
(temp- > next! = NULL)
temp = temp- > अगला;
struct
Node * new_node = create_node (डेटा);
<कोड वर्ग = "सादा"> अस्थायी- > अगला = नया_नोड;
}
void
प्रदर्शन (कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड * अस्थायी) कोड>
कोड वर्ग = "सादा"> { कोड>
कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "स्ट्रिंग"> "तत्व हैं:" कोड> <कोड वर्ग = "सादा">);
जबकि
(temp! = NULL) {
<कोड वर्ग = "कार्य बोल्ड"> प्रिंटफ कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "स्ट्रिंग"> "% d" कोड> <कोड वर्ग = "सादा" ">, अस्थायी- > डेटा);
<कोड वर्ग = "सादा"> अस्थायी = अस्थायी- > अगला;
}
Printf
(
" "
);
}
// ------ -------------------------- कोड>
<कोड वर्ग = "टिप्पणियां"> // परिभाषाएं - END कोड>
<कोड वर्ग = "टिप्पणियां"> // --------------------- ----------- कोड>
कोड संकलित करना: हम उपरोक्त प्रोग्राम को संकलित कर सकते हैं:
हम पहले से ही कार्यक्रम के साथ मुख्य समस्याओं को देख सकते हैं, व्यक्तिगत रूप से या समूह में कोड के साथ काम करना इतना आसान नहीं है।
अगर कोई उपरोक्त के साथ काम करना चाहता है कार्यक्रम, फिर व्यक्ति को जिन समस्याओं का सामना करना पड़ रहा है उनमें से कुछ:
- किसी को पूर्ण स्रोत फ़ाइल से गुजरना होगा। कुछ कार्यक्षमता में सुधार या सुधार करने के लिए।
- आसानी से पुन: उपयोग नहीं किया जा सकता कार्यक्रम अन्य परियोजनाओं के लिए एक आधार के रूप में।
- कोड बहुत अव्यवस्थित है मजबूत> और बिल्कुल भी आकर्षक नहीं है, जिससे कोड के माध्यम से नेविगेट करना बहुत मुश्किल हो जाता है।
एक समूह परियोजना या बड़े कार्यक्रमों के मामले में, उपरोक्त दृष्टिकोण से समग्र लागत, ऊर्जा और विफलता दर में वृद्धि की गारंटी है।
सही तरीका:
हम देखते हैं कि ये पंक्तियाँ हर C / C++ प्रोग्राम में शुरू होती हैं जो "#include" से शुरू होती है।
इसका मतलब है "लाइब्रेरी" हेडर (.h files) में घोषित सभी फ़ंक्शन शामिल करें और संभवतः library.c / cpp फाइलों में परिभाषित करें।
इन पंक्तियों को संकलन समय पर पूर्व-संसाधित किया जाता है।
हम अपने उद्देश्यों के लिए मैन्युअल रूप से ऐसी लाइब्रेरी बनाने का प्रयास कर सकते हैं।
ध्यान रखने योग्य महत्वपूर्ण बातें :
- ".h" फाइलों में केवल प्रोटोटाइप डिक्लेरेशन (जैसे फंक्शंस, स्ट्रक्चर्स) और ग्लोबल वेरिएबल्स होते हैं।
- ".c / .cpp" फाइलों में वास्तविक कार्यान्वयन (हेडर फाइलों में डिक्लेरेशन डेफिनिशन) होता है
- सभी स्रोत फाइलों को संकलित करते समय, सुनिश्चित करें कि एक ही फ़ंक्शन की कई परिभाषाएं, चर, आदि एक ही परियोजना के लिए मौजूद नहीं हैं। (बहुत महत्वपूर्ण)
- स्थिर कार्यों, का उपयोग स्वयं को उस फ़ाइल तक सीमित रखने के लिए करें जिसमें उन्हें घोषित किया गया है।
- बाहरी कीवर्ड का उपयोग करके संदर्भित चर और बाहरी फ़ाइलों का उपयोग करें।
- C++ का उपयोग करते समय, नाम स्थान से सावधान रहें, टकराव से बचने के लिए हमेशा namespace_name:: function (), का उपयोग करें। ol >
प्रोग्राम को छोटे कोड में विभाजित करके:
उपरोक्त प्रोग्राम की जांच करने के बाद, हम देख सकते हैं कि कैसे इस बड़े प्रोग्राम को उपयुक्त छोटे भागों में विभाजित किया जा सकता है और फिर आसानी से संसाधित।
उपरोक्त कार्यक्रम में अनिवार्य रूप से 2 मुख्य कार्य हैं:
1) नोड्स में डेटा बनाएं, डालें और सहेजें।
2) नोड्स प्रदर्शित करना
इस तरह मैं प्रोग्राम को तदनुसार विभाजित कर सकता हूं ताकि:
1) मुख्य फाइल > प्रोग्राम ड्राइवर, इंसर्शन मॉड्यूल से अच्छा रैपर और जहां हम अतिरिक्त फाइलों का उपयोग करते हैं।
2) पेस्ट - > वास्तविक कार्यान्वयन यहाँ है।
उल्लिखित महत्वपूर्ण बिंदुओं के साथ, कार्यक्रम को इसमें विभाजित किया गया है:
linkedlist.c - > ड्राइवर प्रोग्राम शामिल है
insert.c - > प्रविष्टि के लिए कोड शामिल हैlinkedlist.h - > आवश्यक नोड घोषणाएं शामिल हैं
insert.h - > आवश्यक नोड प्रविष्टि घोषणाएं शामिल हैं
प्रत्येक हेडर फ़ाइल में हम इसके साथ शुरू करते हैं:
#ifndef FILENAME_H #define FILENAME_H घोषणाएं ... #endif
जिस कारण से हम #ifndef, #define और #endif, के बीच अपनी घोषणाएं लिखते हैं, वह डेटा प्रकार, चर, आदि जैसे पहचानकर्ताओं की कई घोषणाओं को रोकने के लिए है, जब एक और एक ही हेडर फ़ाइल को कॉल किया जाता है उसी प्रोजेक्ट से संबंधित एक नई फ़ाइल में।
इस नमूना कार्यक्रम के लिए:
insert.h - > इसमें सम्मिलित नोड की घोषणा के साथ-साथ नोड की घोषणा भी शामिल है।
यह याद रखना बहुत महत्वपूर्ण है कि संकलक हेडर फ़ाइल में घोषणाओं को देख सकता है, लेकिन यदि आप कोड लिखने का प्रयास करते हैं तो
मजबूत> में कहीं और घोषणा शामिल है, इसके परिणामस्वरूप एक त्रुटि होगी, क्योंकि संकलक लिंक चरण पर जाने से पहले प्रत्येक .c फ़ाइल को व्यक्तिगत रूप से संकलित करता है। ,
connectedlist.h - > एक सहायक फ़ाइल जिसमें नोड और उसके प्रदर्शन घोषणाएं शामिल हैं जिन्हें उनका उपयोग करने वाली फ़ाइलों के लिए शामिल किया जाना चाहिए।
insert.c - > #include "connectedlist.h", के माध्यम से एक नोड घोषणा शामिल करें जिसमें घोषणा के साथ-साथ insert.h.
connectedlist.c में घोषित अन्य सभी विधि परिभाषाएं शामिल हैं। मजबूत> - > साधारण रैपर, जिसमें एक अनंत लूप होता है जो उपयोगकर्ता को आवश्यक स्थिति में पूर्णांक डेटा डालने के लिए प्रेरित करता है, और इसमें एक विधि भी होती है जो सूची प्रदर्शित करती है।
और ध्यान रखने वाली आखिरी बात यह है कि अर्थहीन फ़ाइलों को एक-दूसरे में शामिल करने से कई ओवरराइड हो सकते हैं और इसके परिणामस्वरूप एक त्रुटि होगी।
उपरोक्त को ध्यान में रखते हुए, आपको सावधानीपूर्वक उपयुक्त रूटीन में विभाजित करना चाहिए।
<टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग =" 0 ">
<कोड क्लास =" टिप्पणियाँ "> // Connectlist.h
# ifndef LINKED_LIST_H
# परिभाषित करें LINKED_LIST_H
struct
Node {
<कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> डेटा;
<कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड * अगला;
<कोड वर्ग = "सादा">};
void
डिस्प्ले (
संरचना कोड> <कोड वर्ग = "सादा"> नोड * अस्थायी);
# endif
insert.h
<तालिका सीमा = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">
// insert.h
# ifndef INSERT_H
< कोड वर्ग = "प्रीप्रोसेसर"> # परिभाषित करें INSERT_H कोड>
कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड;
स्ट्रक्चर
Node * create_node (
int कोड> <कोड वर्ग = "सादा"> डेटा);
<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य कोड> <कोड वर्ग = "सादा"> b_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> डेटा);
<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य कोड> <कोड वर्ग = "सादा"> n_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> डेटा, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> स्थिति);
<कोड वर्ग = "कीवर्ड बोल्ड"> शून्य कोड> <कोड वर्ग = "सादा"> e_insert ( <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना < / कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड"> int कोड> <कोड वर्ग = "सादा"> डेटा);
# endif
insert.c
<टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">
// insert.c
# शामिल "linkedlist.h"
<कोड वर्ग = "टिप्पणियां"> // & quot; & quot; इसलिए प्रीप्रोसेसर // वर्तमान निर्देशिका में दिखता है और
// मानक लाइब्रेरी फ़ाइलें बाद में।
# include "stdlib.h >
struct
Node * create_node (
int
data)
{
< कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड * अस्थायी = ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा" "> नोड *) कोड> <कोड वर्ग = "कार्य बोल्ड"> malloc कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> आकार कोड> <कोड वर्ग = "सादा"> ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड));
<कोड वर्ग = "सादा"> अस्थायी- > डेटा = डेटा;
<कोड वर्ग = "सादा"> अस्थायी- > अगला = शून्य;
रिटर्न
temp;
}
void
b_insert ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड "> int
data)
{
कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड * new_node = create_node (डेटा);
new_node- > अगला = * सिर;
<कोड वर्ग = "सादा"> * सिर = new_node;
}
void
n_insert ( कोड> <कोड वर्ग = "कीवर्ड बोल्ड"> संरचना कोड> <कोड वर्ग = "सादा"> नोड ** सिर, कोड> <कोड वर्ग = "रंग 1 बोल्ड "> int
data,
int
pos)
{
if
(* सिर == NULL) {
<कोड वर्ग = "सादा"> b_insert (सिर, डेटा);
<कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "कीवर्ड बोल्ड"> वापसी कोड> <कोड वर्ग = "सादा">;
}
स्ट्रक्चर कोड> <कोड क्लास =" प्लेन "> नोड * new_node = create_node (डेटा);
स्ट्रक्चर
Node * temp = * head;
के लिए
(
int
i = 0; i "pos - 2;++ i)
temp = अस्थायी- > अगला;
new_node- > अगला = अस्थायी- > अगला;
<कोड वर्ग = "सादा"> अस्थायी- > अगला = नया_नोड; कोड>
<
Shop
Latest questions