मेन्यू

एसटीएल में एल्गोरिदम

algorithms stl

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

एल्गोरिथ्म का एक स्पष्ट अध्ययन और एसटीएल में इसके प्रकार।

csqa परीक्षा प्रश्न और उत्तर पीडीएफ

एसटीएल विभिन्न एल्गोरिदम का समर्थन करता है जो पुनरावृत्तियों के माध्यम से कंटेनरों पर कार्य करते हैं। जैसा कि ये एल्गोरिदम पुनरावृत्तियों पर कार्य करते हैं और सीधे कंटेनरों पर नहीं, उनका उपयोग किसी भी प्रकार के पुनरावृत्तियों पर किया जा सकता है।

एसटीएल एल्गोरिदम अंतर्निहित हैं और इस प्रकार बहुत समय बचाते हैं और अधिक विश्वसनीय भी हैं। वे कोड पुन: प्रयोज्य भी बढ़ाते हैं। ये एल्गोरिदम आम तौर पर केवल एक फ़ंक्शन कॉल हैं और हमें इन्हें लागू करने के लिए संपूर्ण कोड लिखने की आवश्यकता नहीं है।

=> संपूर्ण सी ++ प्रशिक्षण श्रृंखला यहां देखें।

STL में ALGORITHMS

आप क्या सीखेंगे:

एसटीएल एल्गोरिदम के प्रकार

एसटीएल निम्नलिखित प्रकार के एल्गोरिदम का समर्थन करता है

  • एल्गोरिदम खोजें
  • एल्गोरिदम को छांटना
  • संख्यात्मक एल्गोरिदम
  • गैर-रूपांतरण / संशोधित एल्गोरिदम
  • एल्गोरिदम को बदलना / संशोधित करना
  • न्यूनतम और अधिकतम संचालन

हम निम्नलिखित पैराग्राफों में इन प्रत्येक प्रकारों के बारे में विस्तार से चर्चा करेंगे।

खोज और क्रमबद्ध एल्गोरिदम

एसटीएल में प्रमुख खोज एल्गोरिथ्म एक द्विआधारी खोज है। द्विआधारी खोज एल्गोरिथ्म एक क्रमबद्ध सरणी पर संचालित होता है और सरणी को आधे में विभाजित करके तत्व की खोज करता है।

यह पहले सरणी के मध्य तत्व के साथ खोजे जाने वाले तत्व की तुलना करके और फिर खोज को 1 तक सीमित करके किया जाता हैअनुसूचित जनजातिआधा या २एन डीसरणी का आधा भाग इस बात पर निर्भर करता है कि खोजा जाने वाला तत्व मध्य तत्व से कम या अधिक है या नहीं।

द्विआधारी खोज सबसे व्यापक रूप से उपयोग किया जाने वाला खोज एल्गोरिदम है।

इसका सामान्य वाक्य विन्यास है:

binary_search(startaddr, endaddr, key)

कहा पे,

startaddr: सरणी के पहले तत्व का पता।
एंडेड्र्र: सरणी के अंतिम तत्व का पता।
कुंजी: खोजा जाने वाला तत्व।

एसटीएल हमें एक 'सॉर्ट' एल्गोरिथ्म प्रदान करता है जिसका उपयोग किसी विशेष क्रम में एक कंटेनर में तत्वों को व्यवस्थित करने के लिए किया जाता है।

सॉर्ट एल्गोरिथ्म का सामान्य सिंटैक्स है:

sort(startAddr, endAddr);

कहा पे,

startAddr: सॉर्ट किए जाने वाले सरणी का पता शुरू करना।
endAddr: सॉर्ट किए जाने वाले एरे का एंड एड्रेस।

आंतरिक रूप से एसटीएल सरणी को छाँटने के लिए क्विकसॉर्ट एल्गोरिथम का उपयोग करता है।

आइए द्विआधारी खोज और सॉर्ट एल्गोरिथ्म प्रदर्शित करने के लिए एक उदाहरण लें:

#include #include using namespace std; int main() { int testAry() = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 }; int arysize = sizeof(testAry) / sizeof(testAry(0)); sort(testAry, testAry + arysize); cout<<' Sorted Array is '; for(int i=0;i

आउटपुट:

क्रमबद्ध एरे है
0 1 2 3 4 5 6 7 8 9
सरणी में कुंजी = 2 मिली
सरणी में कुंजी = 10 नहीं मिली

दिए गए कोड में, हमने एक सरणी प्रदान की है जिसमें हमें द्विआधारी खोज का उपयोग करके एक प्रमुख तत्व की खोज करने की आवश्यकता है। चूंकि बाइनरी खोज के लिए एक सॉर्ट किए गए सरणी की आवश्यकता होती है, इसलिए हम पहले 'सॉर्ट' एल्गोरिथ्म का उपयोग करके सरणी को सॉर्ट करते हैं और फिर आवश्यक पैरामीटर प्रदान करके 'बाइनरी_सर्च' के लिए एक फ़ंक्शन कॉल करते हैं।

सबसे पहले, हम बाइनरी_सर्च एल्गोरिथ्म को कुंजी = 2 के लिए कहते हैं और फिर कुंजी = 10 के लिए। इस तरह से केवल एक फ़ंक्शन कॉल से हम किसी सरणी पर बाइनरी खोज आसानी से कर सकते हैं या इसे सॉर्ट कर सकते हैं।

संख्यात्मक एल्गोरिदम

STL में हेडर में विभिन्न कार्य होते हैं जो न्यूमेरिक मानों पर काम करते हैं। ये फ़ंक्शंस lcds खोजने से लेकर, gcds से लेकर कंटेनर में तत्वों की राशि की गणना करने के लिए भी होते हैं, जैसे सरणियाँ, किसी निश्चित सीमा पर वैक्टर, आदि।

हम यहां कुछ महत्वपूर्ण कार्यों पर उदाहरणों के साथ चर्चा करेंगे।

(i) संचित करता है

संचित समारोह का सामान्य सिंटैक्स है:

accumulate (first, last, sum);

यह फ़ंक्शन किसी श्रेणी में सभी तत्वों के योग को एक चर राशि में (पहला, अंतिम) देता है। उपरोक्त सिंटैक्स संकेतन में, पहले और अंतिम एक कंटेनर में पहले और अंतिम तत्वों के पते हैं और योग राशि चर का प्रारंभिक मूल्य है।

(ii) आंशिक_सम

आंशिक_सम फ़ंक्शन का सामान्य सिंटैक्स है:

partial_sum(first, last, b)

यहाँ

पहला: कंटेनर के शुरुआती तत्व का पता।
अंतिम: कंटेनर के अंतिम तत्व का पता।
बी: सरणी जिसमें संबंधित सरणी तत्वों का आंशिक योग संग्रहीत किया जाएगा।

इस प्रकार आंशिक_सम फ़ंक्शन संगत सरणी या वेक्टर तत्वों के आंशिक योग की गणना करता है और उन्हें एक अलग सरणी में संग्रहीत करता है।

यदि सीमा में तत्व का प्रतिनिधित्व करता है (पहला, अंतिम) और ख परिणामी सरणी में तत्व का प्रतिनिधित्व करता है तो आंशिक_सम होगा:

b0 = a0
b1 = a0 + a1
b2 = a0 + a1 + a2… इत्यादि।

आइए, दोनों वें को प्रदर्शित करने के लिए एक उदाहरण देखें एक कार्यक्रम में ese कार्य:

#include #include using namespace std; int main() { int A() = {21,25,64,32}; int sum = 0; int b(4); cout<<' Result of accumulate function is: '<

आउटपुट:

संचित समारोह का परिणाम है: 142

सरणी A का आंशिक_सम: 21 46 110 142

जैसा कि उपरोक्त कार्यक्रम में दिखाया गया है, पहले हम संचित फ़ंक्शन का उपयोग करते हुए तत्वों की राशि की गणना करते हैं और फिर हम संबंधित सरणी तत्वों के आंशिक योग की गणना करने के लिए फ़ंक्शन को आंशिक_सम कहते हैं।

एसटीएल और हेडर द्वारा समर्थित अन्य एल्गोरिदम:

  • iota: प्रारंभिक मूल्य के क्रमिक वेतन वृद्धि के साथ एक सीमा को भरता है।
  • कम करना: आदेश को छोड़कर, संचय के समान।
  • अंदरुनी उत्पाद: तत्वों की दो श्रेणियों के आंतरिक उत्पाद की गणना करता है।
  • सन्निकट_संक्रमण: एक सीमा में आसन्न तत्वों के बीच अंतर की गणना करता है।
  • inclusive_scan: आंशिक_सम के समान, ith राशि में ith इनपुट तत्व शामिल है।
  • एक्सक्लूसिव_स्कैन: आंशिक_सम के समान, आईआईटी राशि से आईआईटी इनपुट तत्व को बाहर करता है।

गैर-संशोधित एल्गोरिदम

गैर-संशोधित या गैर-रूपांतरण एल्गोरिदम वे होते हैं जो जिस कंटेनर में काम कर रहे हैं उसकी सामग्री को नहीं बदलते हैं। एसटीएल कई गैर-संशोधित एल्गोरिदम का समर्थन करता है।

हमने उनमें से कुछ को नीचे सूचीबद्ध किया है:

  • गणना: दी गई श्रेणी में मानों की संख्या लौटाता है।
  • बराबरी का: तत्वों को दो श्रेणियों में तुलना करता है और एक बूलियन मान लौटाता है।
  • बेमेल: जब दो पुनरावृत्तियों की तुलना की जाती है और एक मिसमैच होता है, तो पुनरावृत्ति की एक जोड़ी देता है।
  • खोज कर: किसी दिए गए क्रम में दिए गए अनुक्रम की खोज करता है।
  • search_n: गणना मूल्य के अनुक्रम के लिए दी गई सीमा में खोज करता है।

चलो 'गिनती' और 'समान' कार्यों पर अधिक विस्तृत करें !!

गणना (प्रथम, अंतिम, मान) श्रेणी (प्रथम, अंतिम) में in मान ’प्रकट होने की संख्या को लौटाता है।

#include #include using namespace std; int main () { int values() = {5,1,6,9,10,1,12,5,5,5,1,8,9,7,46}; int count_5 = count(values, values+15, 5); cout<<'The number of times '5' appears in array= '<

आउटपुट:

Times 5 'की संख्या एक सरणी = 4 में दिखाई देती है

जैसा कि आप इस कोड में देखते हैं, हम एक ऐरे वैल्यू को परिभाषित करते हैं और फिर 5. की वैल्यू और वैल्यू की रेंज प्रदान करके काउंट फंक्शन को कॉल करते हैं। फंक्शन रिटर्न की संख्या (काउंट) वैल्यू 5 की रेंज में दिखाई देता है।

आइए ‘समान’ फ़ंक्शन को प्रदर्शित करने के लिए एक उदाहरण लें।

बराबर (First1, last1, first2) पहले तत्व द्वारा बताए गए तत्व (first1, last1) में पहले 2 द्वारा बताए गए तत्वों की तुलना करता है और यदि सभी तत्व समान रूप से झूठे हैं तो सही है।

#include #include using namespace std; int main() { int inputs1() = { 1,2,3,4,5,6,7,8}; int inputs2() = { -1,2,1,2,3,4,6,7,8,9}; if (equal( inputs1 , inputs1+8 , inputs2 )==1) cout<<'Elements in Two ranges are equal'; else cout<<'Elements in two ranges are not equal'; }

आउटपुट:

दो श्रेणियों में तत्व बराबर नहीं हैं।

ऊपर दिए गए कोड में, हम दो पूर्णांक सरणियों को परिभाषित करते हैं और 'बराबर' फ़ंक्शन का उपयोग करके उनके संबंधित तत्वों की तुलना करते हैं। जैसे कि सरणी के तत्व समान नहीं हैं, समान रिटर्न गलत है।

एल्गोरिदम को संशोधित करना

जब वे निष्पादित होते हैं, तो संशोधित एल्गोरिदम कंटेनरों की सामग्री को संशोधित या परिवर्तित करते हैं।

सबसे लोकप्रिय और व्यापक रूप से इस्तेमाल किए जाने वाले संशोधित एल्गोरिदम में 'स्वैप' और 'रिवर्स' शामिल हैं जो दो मूल्यों को स्वैप करते हैं और क्रमशः कंटेनर में तत्वों को उलट देते हैं।

आइए इन कार्यों के उदाहरण देखें:

#include #include #include #include using namespace std; int main () { vector vec1 = {1,1,2,3,5}; vector vec2 = {2,4,6,8,10}; swap(vec1,vec2); cout<<'Vector 1 : '; for (auto it = vec1.begin(); it < vec1.end(); ++it) cout << *it << ' '; cout<

आउटपुट:

वेक्टर 1: 2 4 6 8 10

वेक्टर 2: 1 1 2 3 5

उलट वेक्टर 1: 10 8 6 4 2

उलट वेक्टर 2: 5 3 2 1 1

जैसा कि देखा गया है, हमारे पास कार्यक्रम में दो वैक्टर हैं। पहले स्वैप फ़ंक्शन का उपयोग करके हम वेक्टर 1 और वेक्टर 2 की सामग्री को स्वैप करते हैं। अगला, हम रिवर्स फ़ंक्शन का उपयोग करके प्रत्येक वेक्टर की सामग्री को उल्टा करते हैं।

कार्यक्रम वेक्टर 1 और वेक्टर 2 को उनकी सामग्री को स्वैप करने के बाद और सामग्री को उलटने के बाद भी आउटपुट करता है।

न्यूनतम और अधिकतम संचालन

इस श्रेणी में न्यूनतम और अधिकतम कार्य शामिल हैं जो दिए गए दो मानों से क्रमशः न्यूनतम और अधिकतम मान ज्ञात करते हैं।

इन कार्यों का सामान्य वाक्य विन्यास है:

max(objecta, objectb); min(objecta, objectb);

हम also तुलना_फंक्शन ’प्रदान करने के लिए एक तीसरा पैरामीटर भी प्रदान कर सकते हैं या वह मानदंड जो न्यूनतम / अधिकतम मूल्य खोजने के लिए उपयोग किया जाएगा। यदि यह प्रदान नहीं किया जाता है, तो अधिकतम फ़ंक्शन तुलना के लिए operator> 'ऑपरेटर का उपयोग करता है जबकि न्यूनतम फ़ंक्शन not का उपयोग करता है<’ operator for comparison.

प्रोग्राम का उपयोग करके इन कार्यों को प्रदर्शित करें।

#include #include using namespace std; int main() { int x=4, y=5; cout<<'Max of 4 and 5 : '; cout << max(x,y); cout<

आउटपुट:

4 और 5: 5 का मैक्स

4 और 5: 4 का न्यूनतम

3 साल के अनुभव के लिए मैनुअल परीक्षण साक्षात्कार प्रश्न

अधिकतम स्ट्रिंग: छोटी स्ट्रिंग

न्यूनतम स्ट्रिंग: लंबी स्ट्रिंग

उपरोक्त कार्यक्रम स्व-व्याख्यात्मक है क्योंकि हम संख्याओं पर न्यूनतम और अधिकतम फ़ंक्शन का उपयोग करते हैं और फिर स्ट्रिंग्स पर। जैसा कि हमने वैकल्पिक _ Compar_function ’प्रदान नहीं किया था, न्यूनतम / अधिकतम कार्य क्रमशः respectively’ ऑपरेटरों पर कार्य करते थे।

निष्कर्ष

इसके साथ, हम STL में प्रयुक्त प्रमुख एल्गोरिदम पर इस ट्यूटोरियल के अंत में आ गए हैं।

अपने बाद के ट्यूटोरियल्स में, हम कंटेनरों की परवाह किए बिना एसटीएल में उपयोग किए जाने वाले सामान्य कार्यों के साथ पुनरावृत्तियों पर विस्तार से चर्चा करेंगे।

=> आसान सी ++ प्रशिक्षण श्रृंखला के माध्यम से पढ़ें।

अनुशंसित पाठ

^