על מנת להשתמש ב- C ++ priorit_queue, התוכנית צריכה להתחיל בקוד כמו:
#לִכלוֹל
#לִכלוֹל
באמצעות מרחב שמותשעה (ות;
הוא כולל את ספריית התורים לתוך התוכנית.
על מנת להמשיך לקרוא, על הקורא להיות בעל ידע בסיסי ב- C ++.
תוכן המאמר
- בנייה בסיסית
- פונקציות חבר חשובות
- פונקציות תור עדיפות אחרות
- נתוני מחרוזת
- מבנים אחרים של תורי עדיפות
- סיכום
בנייה בסיסית
יש לבנות את מבנה הנתונים תחילה לפני שניתן יהיה להשתמש בו. בנייה כאן פירושה לייצר אובייקט ממעמד התורים של הספרייה. לאחר מכן חייב אובייקט התור לתת לו שם המתכנת. התחביר הפשוט ביותר ליצירת תור עדיפות הוא:
סדר העדיפויות<סוּג>שם התור;
בתחביר זה, הערך הגדול ביותר מוסר תחילה. דוגמה להזדהות היא:
סדר העדיפויות<int>pq;אוֹ
סדר העדיפויות<לְהַשְׁחִיר>pq;
הווקטור והדק הם שני מבני נתונים ב- C ++. ניתן ליצור עם כל אחד מהם עדיפות_קוו. התחביר ליצירת תור עדיפות מהמבנה הווקטורי הוא:
סדר העדיפויות<סוג, וקטור<אותו סוג>, השווה>pq;דוגמה להזדהות זו היא:
סדר העדיפויות<int, וקטור<int>, פחות<int> >pq;שימו לב לפער בין> ו> בסוף ההצהרה. זאת כדי למנוע בלבול עם >>. קוד ההשוואה המוגדר כברירת מחדל הוא פחות, כלומר הערך הגדול ביותר, ולאו דווקא הערך הראשון, יוסר תחילה. אז אפשר פשוט לכתוב את הצהרת הבריאה כך:
סדר העדיפויות<int, וקטור<int> >pq;אם תחילה יש להסיר את הערך הנמוך ביותר, המשפט חייב להיות:
סדר העדיפויות<int, וקטור<int>, גדול יותר<int> >pq;פונקציות חבר חשובות
פונקציית הדחיפה ()
פונקציה זו דוחפת ערך, שהוא הטיעון שלה, אל תוך העדיפות_קו. זה מחזיר ריק. הקוד הבא ממחיש זאת:
pq.לִדחוֹף(10);
pq.לִדחוֹף(30);
pq.לִדחוֹף(עשרים);
pq.לִדחוֹף(חמישים);
pq.לִדחוֹף(40);
סדר העדיפויות הזה קיבל 5 ערכים שלמים בסדר גודל של 10, 30, 20, 50, 40. אם כל האלמנטים האלה אמורים לצאת מהתור העדיפויות, הם ייצאו בסדר גודל של 50, 40, 30, 20, 10.
הפונקציה pop ()
פונקציה זו מסירה מהערך priority_ את הערך בעל העדיפות הגבוהה ביותר. אם קוד ההשוואה גדול יותר, הוא יסיר את האלמנט בעל הערך הקטן ביותר. אם מתקשרים שוב, הוא מסיר את האלמנט הבא בעל הערך הקטן ביותר של השאר; נקרא שוב, הוא מסיר את הערך הקטן הבא להווה, וכן הלאה. זה מחזיר ריק. הקוד הבא ממחיש זאת:
pq.לִדחוֹף('ל');pq.לִדחוֹף('ג');pq.לִדחוֹף('ב');pq.לִדחוֹף('וגם');pq.לִדחוֹף('d');
שים לב שכדי לקרוא לפונקציה חבר, יש לעקוב אחר שם האובייקט בנקודה ולאחר מכן את הפונקציה.
הפונקציה העליונה ()
ה פופ () הפונקציה מסירה את הערך הבא בעדיפות הגבוהה ביותר, אך אינה מחזירה אותו, כמו פופ () היא פונקציית ריק. להשתמש ב חלק עליון() פונקציה על מנת לדעת את הערך בעל העדיפות הגבוהה ביותר שיש להסיר לאחר מכן. ה חלק עליון() הפונקציה מחזירה עותק של הערך בעל העדיפות הגבוהה ביותר ב- prior_queue. הקוד הבא, שבו הערך הבא בעדיפות הגבוהה ביותר הוא הערך הנמוך ביותר, ממחיש זאת
pq.לִדחוֹף('ל');pq.לִדחוֹף('ג');pq.לִדחוֹף('ב');pq.לִדחוֹף('וגם');pq.לִדחוֹף('d');
לְהַשְׁחִירch1=pq.חלק עליון();pq.פּוֹפּ();
לְהַשְׁחִירch2=pq.חלק עליון();pq.פּוֹפּ();
לְהַשְׁחִירch3=pq.חלק עליון();pq.פּוֹפּ();
לְהַשְׁחִירch4=pq.חלק עליון();pq.פּוֹפּ();
לְהַשְׁחִירch5=pq.חלק עליון();pq.פּוֹפּ();
עֲלוּת<<ch1<<''<<ch2<<''<<ch3<<''<<ch4<<''<<ch5<<' n';
הפלט הוא 'a' 'b' 'c' 'd' 'e'.
הפונקציה הריקה ()
אם מתכנת משתמש ב חלק עליון() פונקציה על prior_queue ריק, לאחר האוסף המוצלח, הוא יקבל הודעת שגיאה כגון:
לכן, תמיד בדוק אם תור העדיפות אינו ריק לפני השימוש ב חלק עליון() פוּנקצִיָה. ה ריק() הפונקציה member מחזירה bool, true, אם התור ריק, ושקר אם התור אינו ריק. הקוד הבא ממחיש זאת:
סדר העדיפויות<int>pq;inti1= 10; inti2= 30; inti3= עשרים; inti4= חמישים; inti5= 40;
pq.לִדחוֹף(i1);pq.לִדחוֹף(i2);pq.לִדחוֹף(i3);pq.לִדחוֹף(i4);pq.לִדחוֹף(i5);
בזמן(!pq.ריק())
{
עֲלוּת <<pq.חלק עליון() << '';
pq.פּוֹפּ();
}
עֲלוּת << ' n';
פונקציות תור עדיפות אחרות
הפונקציה size ()
פונקציה זו מחזירה את אורך תור העדיפות, כפי שהקוד הבא ממחיש:
inti1= 10; inti2= 30; inti3= עשרים; inti4= חמישים; inti5= 40;
pq.לִדחוֹף(i1);pq.לִדחוֹף(i2);pq.לִדחוֹף(i3);pq.לִדחוֹף(i4);pq.לִדחוֹף(i5);
intlen=pq.גודל();
עֲלוּת <<len<< ' n';
הפלט הוא 5.
הפונקציה swap ()
אם שני סדרי עדיפות הם מאותו סוג וגודל, ניתן להחליף אותם בפונקציה זו, כפי שהקוד הבא מראה:
inti1= 10; inti2= 30; inti3= עשרים; inti4= חמישים; inti5= 40;
pq1.לִדחוֹף(i1);pq1.לִדחוֹף(i2);pq1.לִדחוֹף(i3);pq1.לִדחוֹף(i4);pq1.לִדחוֹף(i5);
סדר העדיפויות<int>pqA;
intזה 1= 1; intזה 2= 3; intזה 3= 2; intזה 4= 5; intזה 5= 4;
pqA.לִדחוֹף(זה 1);pqA.לִדחוֹף(זה 2);pqA.לִדחוֹף(זה 3);pqA.לִדחוֹף(זה 4);pqA.לִדחוֹף(זה 5);
pq1.לְהַחלִיף(pqA);
בזמן(!pq1.ריק())
{
עֲלוּת <<pq1.חלק עליון() << '';
pq1.פּוֹפּ();
} עֲלוּת<<' n';
בזמן(!pqA.ריק())
{
עֲלוּת <<pqA.חלק עליון() << '';
pqA.פּוֹפּ();
} עֲלוּת<<' n';
הפלט הוא:
& emsp; 5 & emsp; 4 & emsp; 3 & emsp; 2 & emsp; 1
& emsp; 50 & emsp; 40 & emsp; 30 & emsp; 20 & emsp; 10
מקום העבודה () Fuction
ה מקום () הפונקציה דומה לפונקציית הדחיפה. הקוד הבא ממחיש זאת:
inti1= 10; inti2= 30; inti3= עשרים; inti4= חמישים; inti5= 40;
pq1.מקום(i1);pq1.מקום(i2);pq1.מקום(i3);pq1.מקום(i4);pq1.מקום(i5);
בזמן(!pq1.ריק())
{
עֲלוּת <<pq1.חלק עליון() << '';
pq1.פּוֹפּ();
} עֲלוּת<<' n';
הפלט הוא:
50 40 30 20 10
נתוני מחרוזת
בעת השוואת מחרוזות, יש להשתמש במחלקת המחרוזות ולא בשימוש הישיר של המילוליות של המחרוזות מכיוון שהיא תשווה מצביעים ולא את המחרוזות בפועל. הקוד הבא מראה כיצד משתמשים במחלקת המחרוזות:
#לִכלוֹלסדר העדיפויות<חוּט>pq1;
מחרוזת s1=חוּט('עֵט'), s2=חוּט('עִפָּרוֹן'), s3=חוּט('ספר תרגיל'), s4=חוּט('ספר לימוד'), s5=חוּט('סרגל');
pq1.לִדחוֹף(s1);pq1.לִדחוֹף(s2);pq1.לִדחוֹף(s3);pq1.לִדחוֹף(s4);pq1.לִדחוֹף(s5);
בזמן(!pq1.ריק())
{
עֲלוּת <<pq1.חלק עליון() << '';
pq1.פּוֹפּ();
} עֲלוּת<<' n';
הפלט הוא:
& emsp; ספר טקסט & emsp; סרגל & emsp; עיפרון & emsp; עט & ספר
מבנים אחרים של תורי עדיפות
יצירה מפורשת מתוך וקטור
ניתן ליצור תור עדיפות במפורש מתוך וקטור כפי שהקוד הבא מראה:
וֶקטוֹר<int>vtr= {10,30,עשרים,חמישים,40};
סדר העדיפויות<int>pq(vtr.התחל(), vtr.סוֹף());
בזמן(!pq.ריק())
{
עֲלוּת <<pq.חלק עליון() << '';
pq.פּוֹפּ();
} עֲלוּת<<' n';
הפלט הוא: 50 40 30 20 10. הפעם יש לכלול גם את הכותרת הווקטורית. הארגומנטים לפונקציית הקונסטרוקטור לוקחים את מצביעי ההתחלה והסיום של הווקטור. סוג הנתונים של הווקטור וסוג הנתונים של prior_queue חייבים להיות זהים.
על מנת להפוך את הערך הנמוך ביותר לעדיפות, ההצהרה לבנאי תהיה:
סדר העדיפויות<int, וקטור<int>, גדול יותר>int> >pq(vtr.התחל(), vtr.סוֹף()); יצירה מפורשת ממערך
ניתן ליצור תור עדיפות במפורש ממערך כפי שהקוד הבא מראה:
סדר העדיפויות<int>pq(arr, arr+5);
בזמן(!pq.ריק())
{
עֲלוּת <<pq.חלק עליון() << '';
pq.פּוֹפּ();
} עֲלוּת<<' n';
הפלט הוא: 50 40 30 20 10. הארגומנטים לפונקציית הקונסטרוקטור לוקחים את מצביעי ההתחלה והסיום של המערך. arr מחזיר את מצביע ההתחלה, arr+5 מחזיר את המצביע מעבר למערך, ו- 5 הוא גודל המערך. סוג הנתונים של המערך וסוג הנתונים של prior_queue חייבים להיות זהים.
על מנת להפוך את הערך הנמוך ביותר לעדיפות, ההצהרה לבנאי תהיה:
סדר העדיפויות<int, וקטור<int>, גדול יותר<int> >pq(arr, arr+5);הערה: ב- C ++, ה- priority_queue נקרא למעשה מתאם, לא רק מיכל.
קוד השוואה בהתאמה אישית
כל הערכים בתור העדיפות עולים או יורדים אינם האפשרות היחידה לתור העדיפות. לדוגמה, רשימה של 11 מספרים שלמים עבור ערימה מקסימלית היא:
88, 86, 87, 84, 82, 79,74, 80, 81 ,,, 64, 69
הערך הגבוה ביותר הוא 88. אחריו שני מספרים: 86 ו -87, שהם פחות מ -88. שאר המספרים קטנים משלושת המספרים הללו, אך לא ממש בסדר. יש שני תאים ריקים ברשימה. המספרים 84 ו -82 פחות מ -86. המספרים 79 ו -74 פחות מ -87. המספרים 80 ו -81 פחות מ -84. המספרים 64 ו -69 פחות מ -79.
מיקום המספרים עוקב אחר הקריטריונים המרביים-ראה בהמשך. על מנת לספק תכנית כזו עבור prior_queue, על המתכנת לספק קוד השוואה משלו - ראה בהמשך.
סיכום
C_+ue_queue הוא תור ראשון-ראשון-החוצה. פונקציית החברים, לִדחוֹף(), מוסיף ערך חדש לתור. פונקציית החברים, חלק עליון(), קורא את הערך העליון בתור. פונקציית החברים, פופ (), מסיר מבלי להחזיר את הערך העליון של התור. פונקציית החברים, ריק(), בודק אם התור ריק. עם זאת, סדר העדיפויות שונה מהתור, בכך הוא עוקב אחר אלגוריתם עדיפות כלשהו. זה יכול להיות הגדול ביותר, מהראשון לאחרון, או לפחות, מהראשון אחרון. הקריטריונים (אלגוריתם) יכולים להיות גם מוגדרים מתכנתים.