सर्कुलर बफर या सर्कुलर कतार सामान्य कतार का उन्नत संस्करण है जहां अंतिम सूचकांक और टेल इंडेक्स एक गोलाकार संरचना में जुड़े हुए हैं। C++ में सर्कुलर बफर दो तरीकों का पालन करता है: एन्क्यू() और डीक्यू()। हम इन विधियों के आधार पर सर्कुलर बफर या सर्कुलर कतार ऑपरेशन करते हैं।
- एन्क्यू () विधि यह देखने के लिए जाँच करती है कि बफ़र भरा हुआ है या नहीं। अन्यथा, सत्यापित करें कि अंतिम सूचकांक अंतिम है। यदि हां, तो टेल वैल्यू को 0 पर सेट करें। यदि नहीं, तो टेल वैल्यू को उस इंडेक्स के मूल्य से बढ़ाएं।
- Dequeue() फ़ंक्शन गोलाकार कतार में सामने वाले सूचकांक से मान लेता है। यदि कतार खाली है, तो एक संदेश उस खाली कतार को प्रदर्शित करेगा। अन्यथा, यह अंतिम मान प्राप्त करता है और इसे कतार से हटा देता है।
C++ में एक सर्कुलर बफर लागू करने का कार्यक्रम
उल्लिखित दो विधियों का पालन करते हुए, हम C++ में सर्कुलर बफर लागू करते हैं। आइए C++ में वृत्ताकार कतार कार्यान्वयन के सभी चरणों पर विचार करें।
#शामिल<बिट्स/stdc++.h>
नेमस्पेस एसटीडी का उपयोग करना;
MyQueue की संरचना करें
{
int यहाँ सिर , पूँछ ;
int Qआकार;
int यहाँ * NewArr;
MyQueue ( इंट नं ) {
सिर = पूँछ = -1 ;
क्यूआकार = आकार;
NewArr = नया int [ एस ] ;
}
शून्य कतार ( इंट वैल ) ;
int deQueue ( ) ;
शून्य शोक्यू ( ) ;
} ;
कोड से शुरुआत करते हुए, हम सबसे पहले हेड और टेल वेरिएबल्स को आरंभ करने के लिए 'MyQueue' संरचना बनाते हैं। हेड वेरिएबल सामने वाले सूचकांकों का प्रतिनिधित्व करता है और टेल किसी सरणी के पीछे के सूचकांकों का प्रतिनिधित्व करता है। उसके बाद, वृत्ताकार कतार का आकार, जिसे वेरिएबल 'Qsize' द्वारा दर्शाया जाता है, परिभाषित किया जाता है।
फिर, हम 'न्यूएआरआर' के गतिशील रूप से आवंटित सरणी को परिभाषित करते हैं जो परिपत्र कतार के मूल्यों को संग्रहीत करता है। इसके बाद, हम MyQueue() को कॉल करते हैं जो एक कंस्ट्रक्टर है और गोलाकार कतार आकार के लिए 'sz' पैरामीटर पास करते हैं। MyQueue() कंस्ट्रक्टर के अंदर, हम हेड और टेल पॉइंटर्स को '-1' मान निर्दिष्ट करते हैं। यह नकारात्मक मान इंगित करता है कि कतार अब खाली है। आगे बढ़ते हुए, हम 'sz' मान निर्दिष्ट करते हैं जो गोलाकार कतार के आकार का प्रतिनिधित्व करता है। निर्दिष्ट 'sz' आकार के भीतर पूर्णांकों की सरणी बनाने के लिए 'NewArr' परिपत्र कतार को एक नए कीवर्ड के साथ सेट किया गया है।
फिर, हम enQueue() और dequeue() फ़ंक्शंस को परिभाषित करते हैं। एन्क्यू () टेल से परिभाषित गोलाकार कतार में मान सम्मिलित करता है। हालाँकि, वृत्ताकार कतार के शीर्ष में मौजूद तत्व dequeue() फ़ंक्शन द्वारा हटा दिए जाते हैं। showQueue() सदस्य फ़ंक्शन गोलाकार कतार के मान प्रदर्शित करता है।
चरण 1: तत्वों को एक गोलाकार बफर में सम्मिलित करने के लिए एक फ़ंक्शन बनाएं
पहले चरण में, हमने एक वर्ग निर्धारित किया है जहां निजी सदस्यों को आरंभ किया गया है और निजी सदस्य कार्यों को परिपत्र कतार को लागू करने के लिए सेट किया गया है। अब, हम सर्कुलर कतार बनाने के लिए फ़ंक्शन सेट करते हैं और एल्गोरिदम का उपयोग करके सर्कुलर कतार के अंदर मान डालते हैं।
शून्य MyQueue::enQueue ( इंट वैल ){
अगर ( ( सिर == 0 && पूँछ == क्यूआकार - 1 ) || ( पूँछ == ( सिर - 1 ) % ( क्यूआकार - 1 ) ) )
{
अदालत << ' \एन कतार भर गई है' ;
वापस करना ;
}
अन्य अगर ( सिर == - 1 )
{
सिर = पूँछ = 0 ;
NewArr [ पूँछ ] = वैल;
}
अन्य अगर ( पूँछ == क्यूआकार - 1 && सिर ! = 0 )
{
पूँछ = 0 ;
NewArr [ पूँछ ] = वैल;
}
अन्य {
पूँछ ++;
NewArr [ पूँछ ] = वैल;
}
}
यहां, यदि कतार खाली है या अंडरफ्लो है तो हम सर्कुलर कतार में तत्व डालने के लिए 'MyQueue' वर्ग से 'enqueue()' फ़ंक्शन को कॉल करते हैं। 'एनक्यू ()' फ़ंक्शन को 'वैल' पैरामीटर के साथ पास किया जाता है और सर्कुलर कतार की पूंछ से मान डाला जाता है। हम इसके लिए वृत्ताकार कतार में मान सम्मिलित करने के लिए 'यदि-अन्यथा' शर्त निर्धारित करते हैं। पहला 'if' कथन जो 'if ((head == 0 &&tail == Qsize - 1)) || (tail == (head - 1) % (Qsize - 1)))' दो स्थितियों की जांच करता है कि क्या हेड आरंभिक स्थिति में है और पूँछ वृत्ताकार कतार के अंतिम स्थान पर है। फिर, यह जांच करता है कि पूंछ सिर के पीछे एक ही स्थिति में है या नहीं। यदि इनमें से कोई भी शर्त पूरी हो जाती है, तो कतार खाली नहीं होती है और संकेत संदेश उत्पन्न करता है।
इसके बाद, हमारे पास 'अन्य-यदि' स्थिति है जो पहचानती है कि कतार खाली है या नहीं। यदि ऐसा है, तो मान कतार में डाला गया है। चूँकि शीर्ष को -1 के बराबर रखा जाता है, इससे पता चलता है कि कतार खाली है और मान को गोलाकार कतार में डालने की आवश्यकता है। इसके लिए, हम हेड और टेल को 0 के बराबर सेट करते हैं। फिर, हम टेल पोजीशन से मान को 'न्यूएआरआर' सर्कुलर कतार में डालते हैं।
फिर, हमारे पास हमारी तीसरी 'अन्यथा-यदि' स्थिति है जो जांच करती है कि क्या पूंछ कतार की अंतिम स्थिति पर है और सिर कतार की प्रारंभिक स्थिति नहीं है। यह स्थिति तब लागू होती है जब पूंछ अंत तक पहुंच जाती है और प्रारंभिक स्थिति में अभी भी जगह होती है। इसके लिए, हमें हेड को 0 पर सेट करना होगा और तत्व को टेल पोजीशन से जोड़ना होगा। अंत में, यदि दी गई सभी शर्तें पूरी नहीं होती हैं, तो कतार न तो खाली है और न ही भरी हुई है। इस मामले के लिए, हम टेल को 1 से बढ़ाते हैं और मान नई टेल स्थिति से जोड़ा जाता है।
चरण 2: सर्कुलर बफ़र से तत्वों को हटाने के लिए एक फ़ंक्शन बनाएं
हमने enqueue() फ़ंक्शन का उपयोग करके तत्वों को परिपत्र कतार में बनाने और सम्मिलित करने के लिए पिछला कोड सेट किया है। अब, हम सर्कुलर बफर के अतिप्रवाह होने पर तत्वों को हटाने के कार्यान्वयन को परिभाषित करते हैं।
int MyQueue::deQueue ( ){
अगर ( सिर == - 1 )
{
अदालत << ' \एन कतार निःशुल्क है' ;
वापस करना INT_MIN;
}
int MyData = NewArr [ सिर ] ;
NewArr [ सिर ] = -1 ;
अगर ( सिर == पूँछ )
{
सिर = -1 ;
पूँछ = -1 ;
}
अन्य अगर ( सिर == क्यूआकार - 1 )
सिर = 0 ;
अन्य
सिर ++;
वापस करना मेरी जानकारी;
}
दिए गए कोड में, हम हेड इंडेक्स से तत्व को हटाने के लिए 'Myqueue' वर्ग से dequeue() फ़ंक्शन को कॉल करते हैं। तो, हमारे पास 'if' स्टेटमेंट है जो जाँचता है कि कतार खाली है या नहीं। शीर्ष को '-1' मान के साथ सेट किया गया है जो खाली कतार का प्रतिनिधित्व करता है। संदेश उत्पन्न होता है कि कतार खाली है और फिर INT_MIN लौटाता है जो एक इंट के लिए निरंतर न्यूनतम मान है। 'यदि' कथन यह निर्धारित करता है कि कतार खाली है या नहीं। इसके लिए, हम 'MyData' वेरिएबल को परिभाषित करते हैं और तत्व का मान कतार के शीर्ष पर सेट करते हैं। फिर, हम हेड को -1 स्थिति पर सेट करते हैं जो इंगित करता है कि यह मान कतार से हटा दिया गया है। इसके बाद हम जांचते हैं कि हेड और टेल बराबर हैं या नहीं. यदि दोनों समान हैं, तो हम दोनों को '-1' मान निर्दिष्ट करते हैं, जो खाली गोलाकार कतार का प्रतिनिधित्व करता है। अंत में, हम जाँचते हैं कि यदि सिर कतार के अंतिम सूचकांक पर है तो क्या डिक्यू () कार्य करता है। इसके लिए, हम इसे '0' के मान के साथ सेट करते हैं जो सरणी की शुरुआत में घूमता है। यदि दी गई शर्तों में से कोई भी सत्य नहीं है, तो शीर्ष का मान बढ़ जाता है और पंक्तिबद्ध तत्व वापस आ जाता है।
चरण 3: सर्कुलर बफर के तत्वों को दिखाने के लिए एक फ़ंक्शन बनाएं
इस अनुभाग में, हम 'NewArr' सर्कुलर कतार के तत्वों को प्रदर्शित करने के लिए showQueue() फ़ंक्शन को कॉल करते हैं।
शून्य MyQueue::showQueue ( ){
अगर ( सिर == - 1 )
{
अदालत << ' \एन कतार निःशुल्क है' ;
वापस करना ;
}
अदालत << ' \एन वृत्ताकार कतार तत्व: ' ;
अगर ( पूँछ > = सिर )
{
के लिए ( पूर्णांक मैं = सिर ; मैं < = पूँछ ; मैं++ )
अदालत << NewArr [ मैं ] << ' ' ;
}
अन्य
{
के लिए ( पूर्णांक मैं = सिर ; मैं < Qआकार; मैं++ )
अदालत << NewArr [ मैं ] << ' ' ;
के लिए ( पूर्णांक मैं = 0 ; मैं < = पूँछ ; मैं++ )
अदालत << NewArr [ मैं ] << ' ' ;
}
}
कतार की रिक्त स्थिति को पहले सत्यापित किया जाता है। यदि कतार मुफ़्त है तो एक संकेत प्रदर्शित होता है कि गोलाकार कतार मुफ़्त है। अन्यथा, फ़ंक्शन गोलाकार कतार के तत्वों को दिखाएगा। इसके लिए, हम 'यदि' कथन को परिभाषित करते हैं जहां हमारे पास पूंछ होती है जो सिर से बड़ी या उसके बराबर होती है। यह स्थिति उस स्थिति को संभालने के लिए सेट की गई है जब सर्कुलर कतार पूरी नहीं हुई है।
इस मामले के लिए, हम सिर से पूंछ तक पुनरावृत्ति करने और गोलाकार कतार के मानों को प्रिंट करने के लिए 'फॉर' लूप का उपयोग करते हैं। अगला मामला वह है जहां गोलाकार कतार पूरी हो गई है। इसके लिए, हम 'if' स्थिति का उपयोग करके जांच करते हैं जहां पूंछ सिर से छोटी है। फिर, हमें दो लूपों का उपयोग करने की आवश्यकता है जहां पहला सिर से कतार के अंत तक पुनरावृत्त होता है और दूसरा पूंछ की शुरुआत से पुनरावृत्त होता है।
चरण 4: सर्कुलर क्यू प्रोग्राम का मुख्य() फ़ंक्शन बनाएं
अंत में, हम प्रोग्राम का मुख्य() फ़ंक्शन बनाते हैं जहां हम गोलाकार कतार में पांच पूर्णांक डालते हैं और कतार के पूर्णांक प्रदर्शित करते हैं। उसके बाद, हम dequeue() फ़ंक्शन को कॉल करके वृत्ताकार कतार से हटाए गए पूर्णांक दिखाते हैं। कुछ तत्वों को हटाने के बाद, हम enqueue() फ़ंक्शन का उपयोग करके नए तत्वों को सम्मिलित करके कतार को फिर से भरते हैं।
मुख्य प्रवेश बिंदु ( ){
MyQueue वह ( 5 ) ;
// तत्व सम्मिलित करना में गोलाकार कतार
que.enQueue ( ग्यारह ) ;
que.enQueue ( 12 ) ;
que.enQueue ( 13 ) ;
que.enQueue ( 14 ) ;
que.enQueue ( पंद्रह ) ;
// मौजूद तत्वों को प्रदर्शित करें में गोलाकार कतार
क्यू.शोक्यू ( ) ;
// वृत्ताकार कतार से तत्वों को हटाना
अदालत << ' \एन हटाया गया तत्व = ' << क्यू.डीक्यू ( ) ;
अदालत << ' \एन हटाया गया तत्व = ' << क्यू.डीक्यू ( ) ;
क्यू.शोक्यू ( ) ;
que.enQueue ( 16 ) ;
que.enQueue ( 17 ) ;
que.enQueue ( 18 ) ;
क्यू.शोक्यू ( ) ;
वापस करना 0 ;
}
आउटपुट:
वृत्ताकार कतार कार्यान्वयन के परिणाम C++ प्रॉम्प्ट स्क्रीन पर दिखाए जाते हैं।
निष्कर्ष
अंत में, इस लेख में सर्कुलर बफर विषय को गहराई से समझाया गया है। हमने पहले सर्कुलर बफर बनाया, फिर समझाया कि सर्कुलर कतार से कैसे हटाया जाए, और फिर सी++ में सर्कुलर के तत्वों को प्रदर्शित किया।