C++ जोड़ियों के वेक्टर को प्रदर्शित करने और जोड़ियों के वेक्टर को सॉर्ट करने की सुविधा प्रदान करता है। C++ में एक कंटेनर होता है जिसमें दो मान होते हैं जिन्हें एक दूसरे से मैप किया जाता है जिसे 'जोड़ी' और 'जोड़ियों का वेक्टर' कहा जाता है जो एक वेक्टर है जिसमें इनमें से कई जोड़े होते हैं। सॉर्टिंग का अर्थ है डेटा को आवश्यकताओं के अनुसार आरोही या अवरोही क्रम में व्यवस्थित करना। यहां, हम सीखेंगे कि C++ प्रोग्रामिंग में जोड़ों के वेक्टर को कैसे सॉर्ट किया जाए। हम C++ में जोड़ों के वेक्टर को 'आरोही' और 'अवरोही' दोनों क्रमों में क्रमबद्ध कर सकते हैं। हम 'सॉर्ट()' विधि का उपयोग करके जोड़े के वेक्टर को आसानी से सॉर्ट कर सकते हैं। आइए जोड़ों के वेक्टर को क्रमबद्ध करने के लिए यहां कुछ कोड बनाएं।
उदाहरण 1:
आइए यहां हेडर फ़ाइल को शामिल करके कोड शुरू करें जो कि 'bits/stdc++.h' है। इस हेडर फ़ाइल के होने के बाद, हमें और अधिक हेडर फ़ाइलें शामिल करने की आवश्यकता नहीं है क्योंकि इसमें सभी आवश्यक लाइब्रेरीज़ शामिल हैं। फिर, हम 'std' नेमस्पेस जोड़ते हैं और 'main()' फ़ंक्शन को कॉल करते हैं।
अब, हम 'my_vect' नामक 'जोड़ियों का वेक्टर' घोषित करते हैं और 'int' डेटा प्रकार डालते हैं ताकि जो डेटा हम इन जोड़ियों में दर्ज करते हैं वह 'पूर्णांक' डेटा प्रकार हो। इसके नीचे, हम 'my_arr1[]' और 'my_arr2[]' नामों से दो ऐरे आरंभ करते हैं। यहां, हम इन सरणी मानों के साथ जोड़े के पहले और दूसरे मान को प्रारंभ करते हैं। फिर, हम इन मानों को जोड़े के वेक्टर में दर्ज करने के लिए 'फॉर' लूप का उपयोग करते हैं। यहां, हम 'push_back()' फ़ंक्शन का उपयोग करते हैं जो वेक्टर के अंत में मान डालने में सहायता करता है। इस फ़ंक्शन के अंदर, हम 'make_pair' विकल्प डालते हैं जिसका उपयोग 'my_arr1' और 'my_arr2' के दो मानों की जोड़ी ऑब्जेक्ट बनाने के लिए किया जाता है।
इसके बाद, हम फिर से 'फॉर' लूप का उपयोग करके जोड़े के वेक्टर को प्रिंट करते हैं। यहां, जोड़े के वेक्टर के पहले और दूसरे मान प्राप्त करने के लिए 'पहला' और 'दूसरा' कीवर्ड जोड़े गए हैं। यह यहां सॉर्ट किए बिना जोड़े के वेक्टर को प्रिंट करता है। अब, हम जोड़े के वेक्टर को सॉर्ट करने के लिए 'सॉर्ट ()' फ़ंक्शन का उपयोग करते हैं। यहां, 'शुरू ()' और 'अंत ()' फ़ंक्शन को इस 'सॉर्ट ()' फ़ंक्शन में जोड़े के वेक्टर के आरंभ और अंत के रूप में नियोजित किया जाता है।
सॉर्ट करने के बाद, हम 'काउट' का उपयोग करके जोड़े के वेक्टर को फिर से प्रिंट करते हैं और पहले और दूसरे कीवर्ड को 'my_vec[i]' के साथ रखते हैं। अब, जोड़ियों का क्रमबद्ध वेक्टर भी यहां मुद्रित किया गया है।
कोड 1:
#शामिल<बिट्स/stdc++.h>नेमस्पेस एसटीडी का उपयोग करना;
मुख्य प्रवेश बिंदु ( )
{
वेक्टर < जोड़ा < तू तू > > मेरा_वेक्ट;
int my_arr1 [ ] = { 49 , बीस , पंद्रह , 56 } ;
int my_arr2 [ ] = { 37 , बीस , 90 , 55 } ;
पूर्णांक संख्या = sizeof ( my_arr1 ) / का आकार ( my_arr1 [ 0 ] ) ;
के लिए ( int यहाँ मैं = 0 ; मैं < चाहे मैं++ )
my_vect.push_back ( जोड़ी बनाओ ( my_arr1 [ मैं ] ,my_arr2 [ मैं ] ) ) ;
अदालत << 'जोड़ियों के वेक्टर को क्रमबद्ध करने से पहले:' << एंडल;
के लिए ( int यहाँ मैं = 0 ; मैं < चाहे मैं++ )
{
अदालत << my_vect [ मैं ] ।पहला << ' '
<< my_vect [ मैं ] ।दूसरा << एंडल;
}
क्रम से लगाना ( my_vect.begin ( ) , my_vect.end ( ) ) ;
अदालत << ' \एन जोड़े के वेक्टर को सॉर्ट करने के बाद: ' << एंडएल ;
के लिए ( int यहाँ मैं = 0 ; मैं < चाहे मैं++ )
{
अदालत << my_vect [ मैं ] ।पहला << ' '
<< my_vect [ मैं ] ।दूसरा << एंडल;
}
वापस करना 0 ;
}
आउटपुट:
सॉर्ट करने से पहले जोड़े का वेक्टर पहले प्रदर्शित किया जाता है। फिर, हम जोड़े के इस वेक्टर पर सॉर्टिंग तकनीक लागू करते हैं। फिर, जोड़ियों का क्रमबद्ध वेक्टर भी यहां प्रदर्शित होता है। हम देख सकते हैं कि जोड़े के वेक्टर को जोड़ी के पहले तत्व के आधार पर आरोही क्रम में क्रमबद्ध किया गया है।
उदाहरण 2:
इस उदाहरण में, अब हम 'जोड़ियों का वेक्टर' बनाते हैं जिसे 'वेक्टर_1' कहा जाता है और 'int' डेटा प्रकार निर्दिष्ट करते हैं जिसका अर्थ है कि इन जोड़ियों में हम जो जानकारी दर्ज करते हैं वह 'पूर्णांक' डेटा प्रकार की है। निम्नलिखित में 'first_arr[]' और 'Second_arr[]' नाम के साथ दो सरणियाँ प्रारंभ की गई हैं। यहां, हम पहले और दूसरे जोड़े के मूल्यों के लिए इन सरणियों के मूल्यों को आरंभ करते हैं।
इसके बाद, हम इन मानों को 'फॉर' लूप का उपयोग करके जोड़े के वेक्टर में दर्ज करते हैं। 'मेक_पेयर' विकल्प, जिसका उपयोग 'फर्स्ट_एआरआर[]' और 'सेकंड_एआरआर[]' एरेज़ से दो मानों की जोड़ी ऑब्जेक्ट उत्पन्न करने के लिए किया जाता है, को 'पुश_बैक()' विधि के अंदर रखा जाता है जो आइटम को डालने में मदद करता है वेक्टर का अंत.
इसके बाद, हम जोड़े के वेक्टर को आउटपुट करने के लिए एक बार फिर 'फॉर' लूप का उपयोग करते हैं। जोड़े के वेक्टर का पहला और दूसरा मान प्राप्त करने के लिए, 'पहला' और 'दूसरा' कीवर्ड डाले जाते हैं। यह इस बिंदु पर बिना किसी सॉर्टिंग के जोड़ी वेक्टर को आउटपुट करता है। अब हम 'सॉर्ट()' फ़ंक्शन का उपयोग करके अवरोही क्रम में 'जोड़े के वेक्टर' को सॉर्ट करते हैं। इस फ़ंक्शन में, हम 'rbegin()' और 'rend()' फ़ंक्शंस रखते हैं ताकि यह सॉर्टिंग को उलट दे और जोड़ी के मानों के अंत से शुरू हो। यह उन्हें घटते क्रम में व्यवस्थित करता है।
सॉर्टिंग के बाद, हम 'फॉर' लूप का एक बार फिर उपयोग करने के बाद जोड़े के वेक्टर को आउटपुट करने के लिए 'काउट' का उपयोग करते हैं, 'काउट' में 'वेक्टर_1[i]' के साथ पहला और दूसरा कीवर्ड डालते हैं। यहीं पर जोड़ियों का क्रमबद्ध वेक्टर भी मुद्रित होता है।
कोड 2:
#शामिल हैनेमस्पेस एसटीडी का उपयोग करना;
मुख्य प्रवेश बिंदु ( )
{
वेक्टर < जोड़ा < तू तू > > वेक्टर_1;
int पहले_arr [ ] = { 77 , 29 , 97 , पंद्रह } ;
int सेकंड_arr [ ] = { 35 , 89 , 64 , 25 } ;
int s = sizeof ( प्रथम_गिरफ्तारी ) / का आकार ( प्रथम_गिरफ्तारी [ 0 ] ) ;
के लिए ( पूर्णांक मैं = 0 ; मैं < एस; मैं++ )
वेक्टर_1.पुश_बैक ( जोड़ी बनाओ ( प्रथम_गिरफ्तारी [ मैं ] , दूसरा_arr [ मैं ] ) ) ;
अदालत << 'छँटाई से पहले:' << एंडल;
के लिए ( पूर्णांक मैं = 0 ; मैं < एस; मैं++ ) {
अदालत << वेक्टर_1 [ मैं ] ।पहला << ' ' << वेक्टर_1 [ मैं ] ।दूसरा
<< एंडल;
}
क्रम से लगाना ( वेक्टर_1.rbegin ( ) , वेक्टर_1.रेंड ( ) ) ;
अदालत << अंतः << 'छँटाई के बाद:' << एंडल;
के लिए ( पूर्णांक मैं = 0 ; मैं < एस; मैं++ ) {
अदालत << वेक्टर_1 [ मैं ] ।पहला << ' ' << वेक्टर_1 [ मैं ] ।दूसरा
<< एंडल;
}
वापस करना 0 ;
}
आउटपुट:
जोड़ियों का प्री-सॉर्ट वेक्टर पहले यहां दिखाया गया है, उसके बाद जोड़ियों का सॉर्ट किया गया वेक्टर दिखाया गया है, जो इसी तरह सॉर्टिंग प्रक्रिया लागू होने के बाद यहां दिखाया गया है। जैसा कि हम देख सकते हैं, प्रत्येक जोड़ी का प्रारंभिक तत्व यह निर्धारित करता है कि जोड़े के वेक्टर को अवरोही क्रम में कैसे क्रमबद्ध किया जाता है।
उदाहरण 3:
यहां, हम वेक्टर संख्याओं को सॉर्ट करने के लिए 'sortBySecElement' नामक 'बूल' प्रकार का एक फ़ंक्शन बनाते हैं। इस फ़ंक्शन में, हम एक शर्त रखते हैं, 'वैल्यू1.सेकंड <वैल्यू2.सेकंड', जो जोड़े के दोनों वैक्टर के दूसरे मानों की तुलना करता है और संख्याएँ लौटाता है।
फिर, 'मुख्य()' को निम्नलिखित में लागू किया जाता है जहां हम जोड़े का वेक्टर बनाते हैं। निम्नलिखित 'new_array1[]' और 'new_aray2[]' नामक दो सरणियों को प्रारंभ करता है। यहां, हम इन सरणियों में जोड़ियों के मान सम्मिलित करते हैं। इसके बाद, हम इन मानों को जोड़े के वेक्टर में इनपुट करने के लिए 'फॉर' लूप का उपयोग करते हैं। 'पुश_बैक()' विधि के अंदर, जो वेक्टर के अंत में आइटम डालने में सहायता करता है, 'मेक_पेयर' विकल्प है जिसका उपयोग 'new_array1[]' और 'new_array2[ से दो मानों की जोड़ी ऑब्जेक्ट बनाने के लिए किया जाता है। ]” सरणियाँ।
फिर हम दूसरे 'फॉर' लूप का उपयोग करके जोड़े के वेक्टर को आउटपुट करते हैं। जोड़े के वेक्टर का पहला और दूसरा मान प्राप्त करने के लिए 'पहला' और 'दूसरा' कीवर्ड डाले गए हैं। इस स्तर पर कोई सॉर्टिंग नहीं की जाती है, और जोड़ी वेक्टर आउटपुट होता है। अब हम इसे सॉर्ट करने के लिए 'सॉर्ट ()' फ़ंक्शन का उपयोग करते हैं। जोड़े के वेक्टर की शुरुआत और अंत को इस मामले में 'शुरू ()' और 'अंत ()' फ़ंक्शन के उपयोग के माध्यम से 'सॉर्ट ()' फ़ंक्शन को आपूर्ति की जाती है। हम 'sortBySecElement' फ़ंक्शन को भी रखते हैं, जिसे हमने पहले इस 'sort()' फ़ंक्शन के अंदर बनाया था, जहां हम वेक्टर के दूसरे तत्व से जोड़े के वेक्टर को आरोही क्रम में सॉर्ट करने का पैटर्न सेट करते हैं।
अब, हम फिर से 'for' लूप का उपयोग करते हैं। फिर, पहले और दूसरे कीवर्ड को सॉर्टिंग के बाद फिर से जोड़े के वेक्टर का उत्पादन करने के लिए 'काउट' में 'new_vec[i]' के साथ डाला जाता है। यह वह जगह भी है जहां आरोही क्रम में जोड़े के क्रमबद्ध वेक्टर अब मुद्रित होते हैं।
कोड 3:
#शामिल<बिट्स/stdc++.h>नेमस्पेस एसटीडी का उपयोग करना;
बूल sortBySecElement ( स्थिरांक जोड़ी < तू तू > & मूल्य1,
स्थिरांक जोड़ी < तू तू > & मान 2 )
{
वापस करना ( वैल्यू1.सेकंड < वैल्यू2.सेकंड ) ;
}
मुख्य प्रवेश बिंदु ( )
{
वेक्टर < जोड़ा < तू तू > > नई बात
int new_arr1 [ ] = { 3. 4 , 29 , 65 , 48 } ;
int new_arr2 [ ] = { 67 , 19 , 54 , 7 } ;
पूर्णांक मान = sizeof ( new_arr1 ) / का आकार ( new_arr1 [ 0 ] ) ;
के लिए ( int यहाँ मैं = 0 ; मैं < कीमत; मैं++ )
new_vec.push_back ( जोड़ी बनाओ ( new_arr1 [ मैं ] ,new_arr2 [ मैं ] ) ) ;
अदालत << 'छँटाई से पहले:' << एंडएल ;
के लिए ( int यहाँ मैं = 0 ; मैं < कीमत; मैं++ )
{
अदालत << नई बात [ मैं ] ।पहला << ' '
<< नई बात [ मैं ] ।दूसरा << एंडल;
}
क्रम से लगाना ( new_vec.begin ( ) , new_vec.end ( ) , sortBySecElement ) ;
अदालत << अंतः << 'छँटाई के बाद:' << एंडएल ;
के लिए ( int यहाँ मैं = 0 ; मैं < कीमत; मैं++ )
{
अदालत << नई बात [ मैं ] ।पहला << ' '
<< नई बात [ मैं ] ।दूसरा << एंडल;
}
वापस करना 0 ;
}
आउटपुट:
यहां, जोड़ियों के क्रमबद्ध वेक्टर को प्रदर्शित किया जाता है, और जोड़ियों के दूसरे मानों के अनुसार छंटाई की जाती है। जोड़ियों का दूसरा तत्व आरोही क्रम में संग्रहीत किया जाता है और यहां प्रदर्शित किया जाता है।
निष्कर्ष
यह मार्गदर्शिका C++ में 'जोड़ियों के सॉर्ट वेक्टर' के बारे में है। हमने 'जोड़ियों के वेक्टर' को बिना क्रमबद्ध किए खोजा और साथ ही 'जोड़ियों के वेक्टर' को आरोही और अवरोही क्रम में क्रमबद्ध किया। हमने इसे उदाहरणों के साथ चित्रित किया है जिसमें हम C++ प्रोग्रामिंग में इन जोड़ियों की पहली और दूसरी संख्या के अनुसार 'जोड़ियों के वेक्टर' को क्रमबद्ध करते हैं। हमने सीखा कि 'सॉर्ट ()' विधि इस सॉर्टिंग को करने में सहायता करती है।