במדריך הפרטים הזה, נראה את פעולתו של stable_sort() ב-C++.
כיצד להשתמש בפונקציה stable_sort() ב-C++
ב-C++, ה stable_sort() הוא אלגוריתם ספרייה סטנדרטי המסדר את האלמנטים בסדר הולך וגדל ושומר על אותו סדר עבור האלמנטים השווים. המשמעות היא שאם שני אלמנטים שווים, האלמנט שמופיע ראשון במיכל לפני המיון עדיין יופיע ראשון ברשימה הממוינת. פונקציה זו פועלת על ידי חלוקה חוזרת ונשנית של המיכל (מערכים, וקטורים, רשימות מקושרות), מיון אותם בנפרד ואז מיזוגם כדי לקבל את המיכל הממוין. זה מגיע תחת ה <אלגוריתם> קובץ הכותרת.
התחביר הכללי לשימוש ב- stable_sort() ב-C++ הוא:
מיון_יציב ( RandomAccessIterator תחילה , RandomAccessIterator אחרון ) ;
הנה ה ראשון הוא האיטרטור המצביע על האלמנט הראשון בטווח שיש למיין, וה- אחרון הוא האיטרטור המצביע על האלמנט אחרי האלמנט האחרון בטווח שיש למיין.
ה stable_sort() הפונקציה משתמשת בסדר לא יורד כדי למיין את הערכים בטווח [ראשון, אחרון], כלומר מהאלמנט הקטן ביותר לאלמנט הגדול ביותר. הפונקציה כברירת מחדל משווה בין הפריטים דרך פחות מאופרטור (<).
דוגמה 1
שקול את הקוד לדוגמה שלהלן, בקוד זה, יצרנו את רשימה וקטורית ואתחול אותו עם כמה ערכים. לאחר מכן, השתמשנו ב- stable_sort() כדי למיין את ערכי הווקטור הנתון בסדר עולה. הוקטורים הלא ממוינים והממוינים מודפסים על הקונסולה באמצעות הלולאה מבוססת הטווח.
#include#include
#include <אלגוריתם>
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
וֶקטוֹר < int > רשימה = { 5 , 2 , 25 , 4 , 9 , 33 , 38 , 26 } ;
cout << 'מספרים לפני מיון:' ;
לכל אחד ( רשימה. התחל ( ) , רשימה. סוֹף ( ) , [ ] ( int איקס ) {
cout << איקס << '' ;
} ) ;
מיון_יציב ( רשימה. התחל ( ) , רשימה. סוֹף ( ) ) ;
cout << ' \n מספרים לאחר מיון: ' ;
לכל אחד ( רשימה. התחל ( ) , רשימה. סוֹף ( ) , [ ] ( int איקס ) {
cout << איקס << '' ;
} ) ;
לַחֲזוֹר 0 ;
}
דוגמה 2
בדוגמה הנתונה למטה, יצרנו מערך שלמים ואתחול אותו עם כמה ערכים. אז כברירת מחדל, ה stable_sort() ממיין את האלמנטים בסדר עולה:
#include#include <אלגוריתם>
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
int מַעֲרָך [ ] = { 12 , 7 , 7 , 1 , 8 , 7 , 3 , 4 , 22 , 0 } ;
int נ = מידה של ( מַעֲרָך ) / מידה של ( מַעֲרָך [ 0 ] ) ;
cout << 'המערך המקורי הוא: \n ' ;
ל ( int אני = 0 ; אני < נ ; ++ אני ) {
cout << מַעֲרָך [ אני ] << '' ;
}
מיון_יציב ( מַעֲרָך , מַעֲרָך + נ ) ;
cout << ' \n המערך לאחר המיון הוא: \n ' ;
ל ( int אני = 0 ; אני < נ ; ++ אני ) {
cout << מַעֲרָך [ אני ] << '' ;
}
לַחֲזוֹר 0 ;
}
דוגמה 3
ה מיון_יציב לוקח את הפרמטר השלישי כדי לציין את סדר מיון האלמנט. בדוגמה שלהלן, השתמשנו ב- גדול יותר() לתפקד עם stable_sort() כדי למיין את רכיבי המערך בסדר יורד
#include#include <אלגוריתם>
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
int מַעֲרָך [ ] = { 12 , 7 , 7 , 1 , 8 , 7 , 3 , 4 , 22 , 0 } ;
int נ = מידה של ( מַעֲרָך ) / מידה של ( מַעֲרָך [ 0 ] ) ;
cout << 'מערך מקורי: \n ' ;
ל ( int אני = 0 ; אני < נ ; ++ אני ) {
cout << מַעֲרָך [ אני ] << '' ;
}
מיון_יציב ( מַעֲרָך , מַעֲרָך + נ , גדול יותר < int > ( ) ) ;
cout << ' \n מערך לאחר מיון: \n ' ;
ל ( int אני = 0 ; אני < נ ; ++ אני ) {
cout << מַעֲרָך [ אני ] << '' ;
}
לַחֲזוֹר 0 ;
}
שורה תחתונה
ה stable_sort() function ב-C++ הוא אלגוריתם ספרייה סטנדרטי המשמש למיון אלמנטים בקונטיינר בסדר לא יורד תוך שמירה על הסדר היחסי של אלמנטים במיכל עם אותם ערכים. ניתן להשתמש בו עם מיכלים שונים כמו מערכים, וקטורים ורשימות מקושרות. בנוסף, נדרש פרמטר שלישי כדי לציין את סדר המיון של אלמנטים.