C++ מספק את המאפשר להציג את וקטור הזוגות ולמיין את וקטור הזוגות. יש מיכל ב-C++ שמחזיק שני ערכים שממופים זה לזה שנקראים 'זוג' ו'וקטור של זוגות' שהוא וקטור שיש בו הרבה מהזוגות האלה. מיון פירושו לסדר את הנתונים בסדר עולה או יורד בהתאם לדרישות. כאן, נלמד כיצד למיין את וקטור הזוגות בתכנות C++. אנחנו יכולים למיין את וקטור הזוגות בסדר 'עולה' וגם בסדר 'יורד' ב-C++. אנו יכולים למיין בקלות את הווקטור של זוגות על ידי שימוש בשיטת 'sort()'. בואו נעשה כאן כמה קודים כדי למיין את וקטור הזוגות.
דוגמה 1:
בואו נתחיל את הקוד על ידי הכללת קובץ הכותרת כאן שהוא 'bits/stdc++.h'. לאחר שיש לנו קובץ כותרת זה, איננו צריכים לכלול קובצי כותרת נוספים מכיוון שהוא מכיל את כל הספריות הדרושות. לאחר מכן, נוסיף את מרחב השמות 'std' ונקרא לפונקציה 'main()'.
כעת, אנו מכריזים על 'וקטור של זוגות' בשם 'my_vect' ומכניסים את סוג הנתונים 'int' כך שהנתונים שנזין בזוגות אלו הם סוג הנתונים 'שלמים'. מתחת לזה, אנו מאתחלים שני מערכים עם השמות 'my_arr1[]' ו-'my_arr2[]'. כאן, אנו מאתחלים את הערך הראשון והשני של הזוגות עם ערכי המערך הללו. לאחר מכן, אנו משתמשים בלולאת 'for' כדי להזין את הערכים הללו לווקטור הזוגות. כאן, אנו משתמשים בפונקציה 'push_back()' המסייעת בהכנסת הערכים בסוף הווקטור. בתוך פונקציה זו, אנו מניחים את האפשרות 'make_pair' המשמשת לבניית אובייקט הזוג של שני ערכים של 'my_arr1' ו-'my_arr2'.
לאחר מכן, אנו מדפיסים את וקטור הזוגות על ידי שימוש בלולאת 'בעבור' שוב. כאן, מילות המפתח 'הראשונה' וה'שנייה' מתווספות כדי לקבל את הערך הראשון והשני של וקטור הזוגות. זה מדפיס את וקטור הזוגות מבלי למיין כאן. כעת, אנו משתמשים בפונקציה ' sort()' כדי למיין את וקטור הזוגות. כאן, הפונקציות 'begin()' ו-'end()' משמשות כשמעבירים את ההתחלה והסוף של וקטור הזוגות לפונקציית 'סort()' זו.
לאחר המיון, אנו מדפיסים שוב את וקטור הזוגות על ידי שימוש ב-'cout' וממקמים את מילות המפתח הראשונה והשנייה עם 'my_vec[i]'. כעת, הווקטור הממוין של זוגות מודפס גם כאן.
קוד 1:
#includeשימוש במרחב שמות std;
int main ( )
{
וֶקטוֹר < זוג < אתה, אתה > > my_vect;
int my_arr1 [ ] = { 49 , עשרים , חֲמֵשׁ עֶשׂרֵה , 56 } ;
int my_arr2 [ ] = { 37 , עשרים , 90 , 55 } ;
int num = sizeof ( my_arr1 ) / מידה של ( my_arr1 [ 0 ] ) ;
ל ( int אני = 0 ; אני < האם i++ )
my_vect.push_back ( make_pair ( my_arr1 [ אני ] ,my_arr2 [ אני ] ) ) ;
cout << 'לפני מיון וקטור של זוגות: ' << endl;
ל ( int אני = 0 ; אני < האם i++ )
{
cout << my_vect [ אני ] .ראשון << ''
<< my_vect [ אני ] .שְׁנִיָה << endl;
}
סוג ( my_vect.begin ( ) , my_vect.end ( ) ) ;
cout << ' \n לאחר מיון וקטור של זוגות: ' << endl ;
ל ( int אני = 0 ; אני < האם i++ )
{
cout << my_vect [ אני ] .ראשון << ''
<< my_vect [ אני ] .שְׁנִיָה << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
וקטור הזוגות לפני המיון מוצג ראשון. לאחר מכן, אנו מיישמים את טכניקת המיון על וקטור זוגות זה. לאחר מכן, הווקטור הממוין של זוגות מוצג גם כאן. אנו יכולים לראות כי וקטור הזוגות ממוין בסדר עולה על סמך האלמנט הראשון של הזוג.
דוגמה 2:
בדוגמה זו, אנו יוצרים כעת 'וקטור של זוגות' הנקרא 'vector_1' ומקצים את סוג הנתונים 'int' כלומר המידע שאנו מכניסים בזוגות אלו הוא מסוג הנתונים 'שלמות'. שני מערכים עם השמות 'first_arr[]' ו-'second_arr[]' מאותחלים בהמשך. כאן, אנו מאתחלים את ערכי המערכים הללו עבור ערכי הזוגות הראשון והשני.
לאחר מכן, אנו מכניסים את הערכים הללו לווקטור של זוגות באמצעות לולאת 'for'. אפשרות 'make_pair', המשמשת ליצירת אובייקט הזוג של שני ערכים מהמערכים 'first_arr[]' ו-'second_arr[]', ממוקמת בתוך שיטת 'push_back()' שעוזרת להכניס את הפריטים ב- סוף הווקטור.
לאחר מכן, אנו משתמשים בלולאת 'for' פעם נוספת כדי להוציא את וקטור הזוגות. כדי לקבל את הערך הראשון והשני של וקטור הזוגות, מילות המפתח 'הראשונה' וה'שנייה' מוכנסות. זה מוציא את וקטור הזוג ללא כל מיון בשלב זה. כעת אנו ממיינים את 'וקטור הזוגות' על ידי שימוש בפונקציית 'מיין()' בסדר יורד. בפונקציה זו, אנו מניחים את הפונקציות 'rbegin()' ו-'rend()' כך שהיא תהפוך את המיון ותתחיל מסוף הערכים של הזוג. זה מסדר אותם בסדר יורד.
לאחר המיון, אנו משתמשים ב-'cout' כדי להוציא את וקטור הזוגות לאחר שימוש בלולאת 'for' פעם נוספת, תוך הכנסת מילת המפתח הראשונה והשנייה עם 'vector_1[i]' ב-'cout'. כאן מודפס גם הווקטור הממוין של הזיווגים.
קוד 2:
#includeשימוש במרחב שמות std;
int main ( )
{
וֶקטוֹר < זוג < אתה, אתה > > vector_1;
int first_arr [ ] = { 77 , 29 , 97 , חֲמֵשׁ עֶשׂרֵה } ;
int second_arr [ ] = { 35 , 89 , 64 , 25 } ;
int s = sizeof ( first_arr ) / מידה של ( first_arr [ 0 ] ) ;
ל ( int i = 0 ; אני < s; i++ )
vector_1.push_back ( make_pair ( first_arr [ אני ] , second_arr [ אני ] ) ) ;
cout << 'לפני מיון:' << endl;
ל ( int i = 0 ; אני < s; i++ ) {
cout << vector_1 [ אני ] .ראשון << '' << vector_1 [ אני ] .שְׁנִיָה
<< endl;
}
סוג ( vector_1.rbegin ( ) , vector_1.rend ( ) ) ;
cout << endl << 'לאחר מיון:' << endl;
ל ( int i = 0 ; אני < s; i++ ) {
cout << vector_1 [ אני ] .ראשון << '' << vector_1 [ אני ] .שְׁנִיָה
<< endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
וקטור המיון מראש של הזוגות מוצג כאן תחילה, ואחריו הווקטור הממוין של הזוגות שמוצג כאן גם לאחר יישום תהליך המיון. כפי שאנו יכולים לראות, האלמנט הראשוני של כל זוג קובע כיצד וקטור הזוגות ממוין בסדר יורד.
דוגמה 3:
כאן, אנו יוצרים פונקציה מסוג 'bool' בשם 'sortBySecElement' כדי למיין את המספרים הוקטורים. בפונקציה זו אנו מציבים תנאי, 'value1.second < value2.second', אשר משווה את הערכים השניים של שני וקטורי הזוגות ומחזיר את המספרים.
לאחר מכן, ה-'main()' מופעל בהמשך שבו אנו יוצרים את הווקטור של הזוגות. הבא מאתחל שני מערכים בשם 'new_array1[]' ו-'new_aray2[]'. כאן, אנו מכניסים את הערכים של זוגות במערכים אלה. לאחר מכן, אנו משתמשים בלולאת 'for' כדי להזין את הערכים הללו לווקטור הזוגות. בתוך שיטת 'push_back()', המסייעת בהכנסת הפריטים בסוף הווקטור, נמצאת אפשרות 'make_pair' אשר מנוצלת ליצירת אובייקט הזוג של שני ערכים מ-'new_array1[]' ו-'new_array2[ ]” מערכים.
לאחר מכן נוציא את וקטור הזוגות באמצעות לולאת 'for' אחרת. מילות המפתח 'הראשונה' וה'שנייה' מוכנסות כדי לקבל את הערך הראשון והשני של וקטור הזוגות. לא נעשה מיון בשלב זה, והווקטור הזוגי מופק. כעת אנו משתמשים בפונקציה 'sort()' כדי למיין אותה. ההתחלה והסוף של הווקטור של הזוגות מסופקים לפונקציית 'sort()' במקרה זה באמצעות שימוש בפונקציות 'begin()' ו-'end()'. אנו גם מניחים את הפונקציה 'sortBySecElement' שיצרנו בעבר בתוך פונקציית 'sort()' זו, שבה אנו מגדירים את תבנית המיון של וקטור זוגות מהאלמנט השני של הווקטור בסדר עולה.
כעת, אנו משתמשים שוב בלולאת 'ל'. לאחר מכן, מילות המפתח הראשונה והשנייה מוכנסות עם 'new_vec[i]' ב-'cout' כדי לייצר שוב את וקטור הזוגות לאחר המיון. כאן גם מודפס כעת הווקטור הממוין של הזוגות בסדר עולה.
קוד 3:
#includeשימוש במרחב שמות std;
bool sortBySecElement ( זוג קונסט < אתה, אתה > & ערך1,
זוג קונסט < אתה, אתה > & ערך2 )
{
לַחֲזוֹר ( value1.second < value2.second ) ;
}
int main ( )
{
וֶקטוֹר < זוג < אתה, אתה > > חדש_דבר
int new_arr1 [ ] = { 3. 4 , 29 , 65 , 48 } ;
int new_arr2 [ ] = { 67 , 19 , 54 , 7 } ;
int value = sizeof ( new_arr1 ) / מידה של ( new_arr1 [ 0 ] ) ;
ל ( int אני = 0 ; אני < ערך; i++ )
new_vec.push_back ( make_pair ( new_arr1 [ אני ] ,new_arr2 [ אני ] ) ) ;
cout << 'לפני מיון:' << endl ;
ל ( int אני = 0 ; אני < ערך; i++ )
{
cout << חדש_דבר [ אני ] .ראשון << ''
<< חדש_דבר [ אני ] .שְׁנִיָה << endl;
}
סוג ( new_vec.begin ( ) , new_vec.end ( ) , sortBySecElement ) ;
cout << endl << 'לאחר מיון:' << endl ;
ל ( int אני = 0 ; אני < ערך; i++ )
{
cout << חדש_דבר [ אני ] .ראשון << ''
<< חדש_דבר [ אני ] .שְׁנִיָה << endl;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן מוצג הווקטור הממוין של הזוגות, והמיון נעשה לפי הערכים השניים של הזוגות. האלמנט השני של הזוגות מאוחסן בסדר עולה ומוצג כאן.
סיכום
מדריך זה עוסק כולו ב'וקטור המיון של זוגות' ב-C++. חקרנו את 'וקטור הזוגות' ללא מיון וכן מינו את 'וקטור הזוגות' בסדר עולה ויורד. הדגמנו זאת בדוגמאות שבהן אנו ממיינים את 'וקטור הזוגות' לפי המספר הראשון והשני של הזוגות הללו בתכנות C++. למדנו ששיטת 'סort()' מסייעת בביצוע המיון הזה.