lists stl
अपने कार्यान्वयन के साथ एसटीएल में सूचियों के बारे में सभी जानकारी प्राप्त करें।
सूचियाँ अनुक्रमिक कंटेनर हैं। सूची में गैर-सन्निहित स्थानों में तत्व होते हैं। हमने अपने पिछले ट्यूटोरियल में सरणियों और वैक्टर पर चर्चा की है।
सरणी और वेक्टर कंटेनरों के मामले में, चूंकि ये कंटेनर सन्निहित स्मृति में डेटा संग्रहीत करते हैं, इन कंटेनरों के बीच में सम्मिलित ऑपरेशन बहुत महंगा साबित होता है क्योंकि हमें नए तत्वों के लिए जगह बनाने के लिए मौजूदा तत्वों को तदनुसार स्थानांतरित करना होगा।
=> पूर्ण सी ++ ट्यूटोरियल सूची का अन्वेषण करने के लिए यहां देखें।
क्या एक deque c ++ है
आप क्या सीखेंगे:
अवलोकन
सूची एक कंटेनर है जो सरणी और वेक्टर कंटेनरों की इस खामी पर काबू पाती है। यह हमें सूची में कहीं भी तत्वों को सम्मिलित करने की अनुमति देता है, बिना ओवरहेड के। लेकिन जहां तक ट्रैवर्सल का सवाल है, वैक्टर की तुलना में सूचियां धीमी हैं।
इस ट्यूटोरियल में, हम उदाहरणों के साथ एसटीएल में ट्रैवर्सल, मैनिपुलेशन और एक्सेसिंग लिस्ट के विभिन्न ऑपरेशनों के साथ सूचियों के कार्यान्वयन को देखेंगे।
ध्यान दें कि अधिकांश सूची संचालन वैक्टर के समान होते हैं और इसलिए पाठक जो पहले से ही वैक्टर पर हमारे ट्यूटोरियल को पढ़ चुके हैं, उन्हें सूची अवधारणाओं की व्याख्या करने में समस्या नहीं होगी।
घोषणा और प्रारंभिक
सूची कंटेनर को लागू करने और इसके सभी लाभों का उपयोग करने के लिए, हमें अपने कार्यक्रम में एक हेडर फ़ाइल शामिल करने की आवश्यकता है।
#include सूची कंटेनर के लिए सामान्य घोषणा है
std::list listName; उदाहरण के लिए,हम निम्न प्रकार के प्रकार की सूची list mylist ’घोषित कर सकते हैं:
std::list mylist; हम घोषणा के समय सूची को आरंभीकृत भी कर सकते हैं या इसके द्वारा समर्थित किसी एक ऑपरेशन का उपयोग करके इसमें तत्व जोड़ सकते हैं।
आइए देखें कि हम ऊपर बनाई गई सूची को कैसे आरंभ कर सकते हैं।
std::list mylist = {1, 1, 2, 3, 5}; नीचे दिए गए आरंभीकरण को स्मृति में रखा जाएगा:
एक बार जब हम सूची को इनिशियलाइज़ कर लेते हैं, तो हम इटरेटर का उपयोग करके सूची के तत्वों तक पहुँच सकते हैं। Iterator फ़ंक्शंस ’start’ और ter end ’हमें सूची तत्वों के माध्यम से आगे बढ़ने में मदद करते हैं।
ध्यान दें: सूची के लिए इटरेटर भी अन्य पुनरावृत्तियों का समर्थन करता है जैसे रिवर्स इटरेटर्स (रबगिन, रेंडरिंग), निरंतर पुनरावृत्त (केगिन, सेन्ड) और निरंतर रिवर्स पुनरावृत्तियों (क्राइबिन, क्रेंड) और वैक्टर की तरह उपयोग किया जा सकता है।
निम्नलिखित उदाहरण से पता चलता है।
#include #include #include #include using namespace std; int main() { list mylist = {1, 1, 2, 3, 5}; cout<<”List elements are: “; list::iterator it; for(it=mylist.begin();it!=mylist.end();++it) cout<<*it<<” “; }आउटपुट:
सूची तत्व हैं: 1 1 2 3 5
इस प्रकार उपरोक्त उदाहरण में, हमने फिबोनाची अनुक्रम की एक सूची घोषित की है। अगला, हम सूची के समान प्रकार का पुनरावृत्त घोषित करते हैं और फिर लूप के लिए उपयोग करते हुए, हम सूची सामग्री को शुरू से अंत तक प्रिंट करते हैं।
अब हम उन कार्यों या फ़ंक्शंस पर जाते हैं जो एसटीएल में कंटेनर को सूचीबद्ध करते हैं।
सूची संचालन
- सम्मिलित करें: दिए गए स्थान पर एक तत्व डालने के लिए उपयोग किया जाता है। पहले सम्मिलित किए गए तत्व की ओर इशारा करते हुए एक पुनरावृत्ति देता है।
सम्मिलित करें (स्थिति, संख्या_ संख्या, चुनाव)
कहा पे,
पद => वह स्थिति जिस पर नए तत्व डाले जाने हैं।
num_elem => सम्मिलित किए जाने वाले तत्वों की संख्या; 1 से चूक।
आइटम => वास्तविक मूल्य डाला जाएगा।
आइए एक उदाहरण लेकर इंसर्ट फंक्शन को समझें।
#include #include // for list operations using namespace std; int main() { list mylist = {1,1,2}; list::iterator it = mylist.begin(); // iterator to point to 4th position advance(it,` 3); // inserts 3 at 4th position mylist.insert(it, 3); cout << 'The list after inserting' << ' 1 element using insert() is : '; for (list::iterator i = mylist.begin();i != mylist.end();i++) cout << *i << ' '; cout << endl; }आउटपुट:
डालने के बाद 1 तत्व डालने के बाद की सूची है: 1 1 2 3
यह 4 में केवल एक तत्व सम्मिलित करने के लिए एक उदाहरण हैवेंसूची में स्थिति जो अंततः अंतिम स्थिति है। इसलिए, पहले, हमारे पास एक सूची है, जिसके लिए हमने सूची की शुरुआत की ओर इशारा करते हुए पुनरावृत्त परिभाषित किया है। फिर हम इस पुनरावृत्ति को 4 पर स्थानांतरित करते हैंवेंस्थिति और फिर 1 तत्व सम्मिलित करने के लिए डालें कॉल करें।
हम सम्मिलित फ़ंक्शन में दूसरे पैरामीटर को निर्दिष्ट करके एक से अधिक तत्व सम्मिलित कर सकते हैं। जब भी इसे निर्दिष्ट नहीं किया जाता है, तो यह 1 को डिफॉल्ट करता है।
- पीछे धकेलना :सूची के अंत में एक नया तत्व जोड़ता है।
- push_front :सूची की शुरुआत में एक नया तत्व जोड़ता है।
आइए एक उदाहरण देखते हैं जो push_back और push_front फ़ंक्शंस के उपयोग को प्रदर्शित करता है।
#include #include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3}; cout<<'List elements are: '; printlist(mylist); mylist.push_front(0); mylist.push_back(5); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }आउटपुट:
सूची तत्व हैं: 1 1 2 3
पुश_फ्रंट और पुश_बैक के बाद सूची सामग्री: 0 1 1 2 3 5
इस उदाहरण में, हम पहले सभी दो तत्वों को बनाते हैं और उन्हें सूचीबद्ध करते हैं, क्रमशः सामने और पीछे वाले प्रत्येक को क्रमशः push_front और push_back फ़ंक्शंस का उपयोग करते हुए। दोनों फ़ंक्शन निष्पादित होने के बाद आउटपुट परिवर्तित सूची दिखाता है।
- pop_back :सूची में अंतिम तत्व को हटाता है जिससे सूची आकार 1 से कम हो जाता है।
- pop_front :सूची में पहला तत्व निकालता है जिससे सूची आकार 1 से कम हो जाता है।
निम्नलिखित उदाहरण सूची के pop_back और pop_front संचालन के उपयोग को दर्शाता है।
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); mylist.pop_front(); mylist.pop_back(); cout<<'
List contents after push_front and push_back: '; printlist(mylist); }आउटपुट:
सूची तत्व हैं: 1 1 2 3 5
पुश_फ्रंट और पुश_बैक: 1 2 3 के बाद सूची सामग्री
जैसा कि ऑपरेशन की परिभाषा में बताया गया है कि प्रत्येक ऑपरेशन pop_front और pop_back सूची के आगे और पीछे से तत्व को हटाता है अर्थात् सूची का पहला और अंतिम तत्व क्रमशः और इस प्रकार हर बार यह सूची के आकार को 1 से कम करता है।
- आकार :सूची का आकार यानी सूची में तत्वों की संख्या लौटाता है।
- खाली :सूची खाली है, तो जाँच करता है।
- मिटा :सूची से किसी तत्व या श्रेणी का तत्व निकालता है।
- स्पष्ट :सूची से सभी तत्वों को 0 आकार में बनाकर निकाल देता है।
नीचे दिए गए सभी उपरोक्त कार्यों के उपयोग को प्रदर्शित करने के लिए एक उदाहरण है, अर्थात् आकार, खाली, मिटा और स्पष्ट।
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'size of the list: '< आउटपुट:
सूची तत्व हैं: 1 1 2 3 5
सूची का आकार: 5
पहले तत्व को मिटाने के बाद सूची: 1 2 3 5
सूची का नया आकार: 4
स्पष्ट के बाद सूची का आकार: 0
उपरोक्त कार्यक्रम सूची की क्षमता से संबंधित सभी चार कार्यों को प्रदर्शित करता है। हम देखते हैं कि जब हम सूची के 1 तत्व को मिटाते हैं तो सूची आकार 1 से घट जाता है। जब हम सूची पर एक स्पष्ट ऑपरेशन कहते हैं, तो आकार 0 होता है जिसका अर्थ है कि सूची के सभी तत्व हटा दिए गए हैं।
- सामने :सूची के पहले तत्व का मान लौटाता है।
- वापस :सूची के अंतिम तत्व का मान लौटाता है।
- विनिमय :एक सूची की सामग्री को उसी आकार और प्रकार की अन्य सूची की सामग्री के साथ स्वैप करता है।
- उलटना :एक एल्गोरिथ्म जो सूची को उलट देता है।
- तरह :दी गई सूची को सॉर्ट करता है।
नीचे का उदाहरण सामने, पीछे, रिवर्स, सॉर्ट और स्वैप कार्यों के उपयोग को दर्शाता है।
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 2, 3, 5}; cout<<'List elements are: '; printlist(mylist); cout<<'
Front of the list: '< आउटपुट:
सूची तत्व हैं: 1 1 2 3 5
सूची के सामने: 1
सूची का पिछला: 5
उलट सूची: 5 3 2 1 1
विषम सूची की सामग्री: १ ३ ५। ९
स्वैप करने के बाद
कैसे खिड़कियों पर जार फ़ाइलों को चलाने के लिए
mylist: १ ३ ५ 5 ९
ओडलिस्ट: 5 3 2 1 1
इस कोड में, पहले, हम सूची के सामने और पीछे के मानों को प्रिंट करते हैं। फिर इस सूची को उलट दिया जाता है और उलट सूची मुद्रित की जाती है। उसके बाद, हम विषम संख्याओं की एक और सूची को परिभाषित करते हैं जो किसी भी क्रम में नहीं है और हम इस सूची को क्रमबद्ध करने के लिए 'सॉर्ट' एल्गोरिथम कहते हैं। फिर हम स्वैप फ़ंक्शन का उपयोग करके दो सूचियों को स्वैप करते हैं और एक्सचेंज किए गए सूचियों को प्रिंट करते हैं।
- ब्याह :इस फ़ंक्शन का उपयोग किसी निर्दिष्ट सूची में एक सूची की सामग्री को दूसरी सूची में स्थानांतरित करने के लिए किया जाता है।
दोनों सूचियाँ एक ही प्रकार की होनी चाहिए।
ब्याह (स्थिति, सूची);
कहां है,
स्थिति => वह स्थिति जिस पर सूची सामग्री को स्थानांतरित किया जाना है।
सूची => सूची जिनके तत्वों को स्थानांतरित किया जाना है।
नीचे दिया गया उदाहरण ब्याह फ़ंक्शन के उपयोग को दर्शाता है।
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1, 8,13}; cout<<'List elements are: '; printlist(mylist); list seclist = {2,3,5}; cout<<'list to be spliced: '; printlist(seclist); list:: iterator it = mylist.begin(); it ++; it++; mylist.splice(it,seclist); cout<<'
List contents after splicing at position 2: '; printlist(mylist); } आउटपुट:
सूची तत्व हैं: 1 1 8 13
लिस्ट किया जाना है: 2 3 5
2: 1 1 2 3 5 8 13 पर स्परिंग के बाद सूची सामग्री
उदाहरण दिखाता है कि हम दो सूचियों का उपयोग करते हैं। सबसे पहले, mylist के लिए पुनरावृत्त को दो पदों पर ले जाया जाता है और फिर दूसरी सूची की सामग्री को पहली सूची के तीसरे स्थान पर स्थानांतरित करने के लिए ब्याह समारोह को बुलाया जाता है।
- जाओ :एक विशिष्ट स्थिति में एक सूची की सामग्री को दूसरे में स्थानांतरित करने के लिए उपयोग किए जा सकने वाले ब्याह समारोह के विपरीत, मर्ज ऑपरेशन सीधे एकल सूची बनाने के लिए दो सूचियों का विलय करता है। मर्ज ऑपरेशन के लिए, दोनों सूचियों को क्रमबद्ध क्रम में होना चाहिए।
नीचे दिए गए मर्ज फ़ंक्शन को प्रदर्शित करने के लिए एक उदाहरण है।
#include #include #include using namespace std; void printlist(list mylist) { list :: iterator it; for(it = mylist.begin(); it != mylist.end(); ++it) cout <<*it<<' '; cout << '
'; } int main() { std::list mylist = {1, 1,2,3,5,8}; list seclist = {4,6,7}; cout<<'First List: '; printlist(mylist); cout< आउटपुट:
पहली सूची: 11 2 3 5 8
दूसरी सूची: 4 6 7
दो सूचियों को मर्ज करने के बाद सूची सामग्री:
1 1 2 3 4 5 6 7 8
इस प्रकार उपरोक्त कार्यक्रम में, हमारे पास दो सूचियाँ हैं जो क्रमबद्ध हैं। हम इन दो सूचियों पर मर्ज ऑपरेशन कहते हैं। परिणामी सूची एक क्रमबद्ध सूची है जिसमें दोनों सूचियों के तत्व शामिल हैं।
निष्कर्ष
हम STL में सूचियों पर इस ट्यूटोरियल के अंत में आ गए हैं। हमें उम्मीद है कि इस ट्यूटोरियल ने आपको एसटीएल में सूचियों पर काफी ज्ञान दिया होगा।
=> सी ++ प्रशिक्षण ट्यूटोरियल के ए-जेड को देखने के लिए यहां देखें।
अनुशंसित पाठ