stacks queues stl
उदाहरण के साथ STL में ढेर और कतारों के कार्यान्वयन को जानें।
एसटीएल में ढेर और कतारें दो कंटेनर हैं जो प्रकृति में बहुत बुनियादी हैं। वे सबसे सरल कंटेनर हैं जिनके पास सॉफ्टवेयर प्रोग्रामिंग में व्यापक अनुप्रयोग हैं।
इस ट्यूटोरियल में, हम एसटीएल में इन दोनों कंटेनरों का विस्तृत कार्यान्वयन देखेंगे। हम उदाहरण के साथ ढेर और कतार द्वारा समर्थित विभिन्न कार्यों से भी गुजरेंगे।
=> यहाँ सरल सी ++ प्रशिक्षण श्रृंखला देखें।
आप क्या सीखेंगे:
ढेर
एसटीएल में स्टैक कंटेनर एक प्रकार का कंटेनर एडेप्टर है। इसका उपयोग C ++ में स्टैक डेटा संरचना को दोहराने के लिए किया जाता है। स्टैक कंटेनर तत्वों का एक सेट है जिसमें तत्वों को एक छोर पर डाला जाता है और उसी छोर पर हटा दिया जाता है।
जोड़ और विलोपन के इस सामान्य बिंदु को 'स्टैक के शीर्ष' के रूप में जाना जाता है।
स्टैक का सचित्र प्रतिनिधित्व नीचे दिखाया गया है।
जैसा कि उपरोक्त प्रतिनिधित्व में दिखाया गया है, स्टैक एक कंटेनर है जिसमें तत्वों को जोड़ा जाता है और एक ही छोर से हटा दिया जाता है जिसे स्टैक के शीर्ष कहा जाता है।
चूंकि जोड़ और विलोपन एक ही छोर पर होते हैं, इसलिए हम कह सकते हैं कि स्टैक कंटेनर LIFO (आखिरी में, पहले बाहर) काम का प्रकार है। इसका मतलब है, कि पहले जोड़ा गया तत्व डिलीट करने वाला आखिरी होगा।
स्टैक कंटेनर को लागू करने के लिए, हमें अपने प्रोग्राम में हेडर को शामिल करना होगा।
#include
स्टैक कंटेनर के लिए सामान्य घोषणा सिंटैक्स है:
stack stackName;
स्टैक संचालन
अगला, एसटीएल समर्थन में कंटेनर को ढेर करने वाले विभिन्न कार्यों पर चर्चा करते हैं।
- धक्का दें : स्टैक में एक तत्व डालने के लिए पुश ऑपरेशन का उपयोग किया जाता है। यह ऑपरेशन हमेशा स्टैक के शीर्ष पर तत्वों को जोड़ता है।
प्रकार पूर्णांक के एक खाली स्टैक रहस्य पर विचार करें ।
अगला, स्टैक में 1 तत्व जोड़ें।
फिर, हम स्टैक में तत्व 3 जोड़ते हैं।
प्रतिनिधित्व के अनुसार, एक धक्का ऑपरेशन के परिणामस्वरूप, ढेर के शीर्ष पर एक तत्व जोड़ा जाता है। प्रत्येक पुश ऑपरेशन के बाद, स्टैक का आकार 1 से बढ़ जाता है।
- पॉप : स्टैक से किसी तत्व को निकालने के लिए पॉप ऑपरेशन का उपयोग किया जाता है। निकाला गया तत्व वह है जो स्टैक के शीर्ष द्वारा इंगित किया गया है। पॉप ऑपरेशन के परिणामस्वरूप, स्टैक का आकार 1 से कम हो जाता है।
आइए देखें कि पॉप ऑपरेशन कैसा दिखता है:
ऊपर के रूप में स्टैक रहस्य पर विचार करें जिसमें हमने पहले से ही 2 तत्वों को धकेल दिया है।
अब हमें फंक्शन पॉप कहते हैं ()। जब इस कॉल को निष्पादित किया जाता है, तो स्टैक के शीर्ष पर स्थित तत्व हटा दिया जाता है और नीचे दिखाए गए अनुसार below टॉप ’अगले तत्व को इंगित करता है।
यदि हम फिर से पॉप () कहते हैं, तो अगला तत्व (इस मामले में 1) को हटा दिया जाएगा, जिससे रिक्त स्टैक हो जाएगा।
शीर्ष 50 sql मुश्किल साक्षात्कार साक्षात्कार पीडीएफ
- ऊपर : स्टैक का सबसे ऊपरी तत्व देता है।
- खाली : चेक करता है कि स्टैक खाली है या नहीं।
- आकार: स्टैक का आकार देता है यानी स्टैक में तत्वों की संख्या।
नीचे दिए गए कार्यों को बेहतर ढंग से समझने के लिए स्टैक कार्यान्वयन का एक उदाहरण है।
#include #include using namespace std; void printStack(stack stk) { while (!stk.empty()) { cout << ' ' << stk.top(); stk.pop(); } cout << '
'; } int main () { stack oddstk; oddstk.push(1); oddstk.push(3); oddstk.push(5); oddstk.push(7); oddstk.push(9); cout << 'The stack is : '; printStack(oddstk); cout << '
Size of stack: ' << oddstk.size(); cout << '
Top of stack: ' << oddstk.top(); cout << '
oddstk.pop() : '; oddstk.pop(); printStack(oddstk); cout<<'
Another pop(): '; oddstk.pop(); printStack(oddstk); return 0; }
उपरोक्त उदाहरण स्पष्ट रूप से पुश ऑपरेशन दिखाता है जो स्टैक उत्पन्न करता है। यह लगातार दो पॉप ऑपरेशन के बाद भी स्टैक दिखाता है।
इस प्रकार हमने एसटीएल में स्टैक और इसके संचालन को देखा है। इसके अलावा, इस ट्यूटोरियल में, हम अभी तक एक और सरल एसटीएल कंटेनर के विस्तृत कार्यान्वयन को देखेंगे जो कि 'कतार' है।
पंक्ति
कतार एसटीएल में एक और कंटेनर है जो बहुत सरल है और उपयोगी भी है। कतार कंटेनर C ++ में कतार डेटा संरचना की प्रतिकृति है। स्टैक के विपरीत, कतार कंटेनर में, दो छोर होते हैं, अर्थात् सामने, और पीछे।
तत्वों को कतार के सामने से हटाए जाने पर पीछे कतार में जोड़ा जाता है। सामान्य तौर पर, कतार FIFO (फर्स्ट इन, फर्स्ट आउट) प्रकार की व्यवस्था का उपयोग करती है।
एक कार्यक्रम में एक कतार कंटेनर को लागू करने के लिए, हमें कोड में एक हेडर शामिल करना होगा।
#include
कतार की घोषणा के लिए सामान्य वाक्यविन्यास है:
कतार queue_name;
हम कतार कंटेनर को निम्नानुसार घोषित करते हैं:
Queue myqueue;
कतार संचालन
अब, हम कतार द्वारा समर्थित विभिन्न कार्यों को देखेंगे।
- धक्का दें: फ़ंक्शन 'पुश' कतार के अंत में तत्व को जोड़ता है यानी कतार के पीछे।
- पॉप: फ़ंक्शन 'पॉप' कतार के पहले तत्व को हटाता है यानी कतार के सामने वाला तत्व।
आइए हम कतार के धक्का और पॉप कार्यों को समझते हैं।
माईक्यू के ऊपर घोषित एक खाली कतार पर विचार करें। अब हम ऑपरेशन के साथ कतार में एक सम संख्या 2 को धकेलते हैं
myqueue.push (2);
अब कतार दिखेगी:
सॉफ्टवेयर परीक्षण में लोडरनर क्या है
अगला, हम ‘4 'को'‘ myqueue.push (4) 'कॉल के साथ कतार में जोड़ते हैं।
अब कतार नीचे दिख रही है:
जैसा कि ऊपर देखा गया है, तत्वों को पीछे के छोर या पीछे से कतार में धकेल दिया जाता है।
अब हम myqueue पर पॉप ऑपरेशन करते हैं।
myqueue.pop ();
इसलिए जैसा कि हम देखते हैं, जब पॉप () कहा जाता है, कतार के सामने का तत्व हटा दिया जाता है। इसका मतलब यह है कि कतार में प्रवेश करने वाला पहला तत्व कतार से बाहर होने वाला पहला तत्व है।
- सामने: यह फ़ंक्शन कतार के पहले तत्व का संदर्भ देता है।
- वापस: वापस कतार में अंतिम तत्व का संदर्भ देता है।
- खाली: जाँच करता है कि कतार खाली है या नहीं।
- आकार: पंक्ति का आकार यानी कतार में तत्वों की संख्या लौटाता है।
नीचे दिया गया एक उदाहरण कार्यक्रम है जो कतार कंटेनर द्वारा उपयोग किए गए कार्यों को प्रदर्शित करता है।
#include #include using namespace std; void printQueue(queue myqueue) { queue secqueue = myqueue; while (!secqueue.empty()) { cout << ' ' << secqueue.front(); secqueue.pop(); } cout << '
'; } int main() { queue myqueue; myqueue.push(2); myqueue.push(4); myqueue.push(6); myqueue.push(8); cout << 'The queue myqueue is : '; printQueue(myqueue); cout << '
myqueue.size() : ' << myqueue.size(); cout << '
myqueue.front() : ' << myqueue.front(); cout << '
myqueue.back() : ' << myqueue.back(); cout << '
myqueue.pop() : '; myqueue.pop(); printQueue(myqueue); return 0; }
आउटपुट:
कतार मैक्यू है: 2 4 6 8
myqueue.size (): 4
myqueue.front (): 2
myqueue.back (): 8
myqueue.pop (): 4 6 8
जैसा कि ऊपर दिखाया गया है, हम पहले एक कतार कंटेनर घोषित करते हैं। फिर पुश ऑपरेशन का उपयोग करके हम इसमें पहले चार सम संख्याएँ जोड़ते हैं। उसके बाद हम कतार से तत्व को पॉप करते हैं और परिवर्तित कतार को प्रदर्शित करते हैं।
निष्कर्ष
इसके साथ, हम इस ट्यूटोरियल के अंत में ढेर और कतारों पर आ गए हैं। जैसा कि पहले ही उल्लेख किया गया है कि ये सबसे सरल कंटेनर हैं जो हमारे पास एसटीएल में हैं। कतार कंटेनर का एक और रूपांतर 'प्राथमिकता कतार' के रूप में जाना जाता है।
हमारे आगामी ट्यूटोरियल में, हम STL में प्राथमिकता कतार पर अधिक चर्चा करेंगे !!
=> स्क्रैच से C ++ जानने के लिए यहाँ जाएँ।
अनुशंसित पाठ
- एसटीएल में प्राथमिकता कतार
- एसटीएल में सूची
- एसटीएल में एमएपीएस
- एसटीएल में सेट करें
- एसटीएल में गिरफ्तार
- चित्रण के साथ C ++ में कतार डेटा संरचना
- STL में Iterators
- चित्रण के साथ C ++ में प्राथमिकता कतार डेटा संरचना