הבנת Unordered_Map::Find()
הפונקציה unordered_map::find() נועדה לאתר אלמנט המשויך למפתח שצוין בתוך 'unordered_map'. ההצהרה שלו משתנה על סמך אם האובייקט הוא קבוע או לא, מה שמספק גמישות בשימוש בו.
איטרטור למצוא ( const סוג מפתח & ק ) ;זה משמש כאשר ה-'unordered_map' אינו מסומן קבוע. קוד זה מחזיר איטרטור המצביע על האלמנט שנמצא.
const_iterator למצוא ( const סוג מפתח & ק ) const ;
גרסה זו חלה כאשר 'מפה_בלתי מסודרת' מסומנת קבועה. הוא מחזיר איטרטור קבוע עם התנהגות דומה לגרסה הלא קבועה.
פרמטרים:
זה דורש פרמטר בודד, 'k', שהוא המפתח לחיפוש בתוך 'מפה_בלתי מסודרת'.
ערך החזרה:
ערך ההחזרה תלוי בהסמכה של האובייקט 'unordered_map'.
השיטה מחזירה איטרטור לא קבוע אם האובייקט אינו מוסמך כל הזמן.
אם האובייקט הוא קבוע-qualified, השיטה מחזירה איטרטור קבוע.
מורכבות זמן:
מורכבות הזמן של std::unordered_map::find() חיונית להבנת היעילות שלו:
במקרה הממוצע, מורכבות הזמן קבועה (O(1)), מה שהופך אותו ליעיל ביותר עבור מקרי שימוש טיפוסיים.
בתרחיש הגרוע ביותר, מורכבות הזמן הופכת ללינארית (O(n)). עם זאת, תרחיש זה נדיר בפועל.
דוגמה 1:
בוא נחקור דוגמה מעשית כדי להמחיש את השימוש והיתרונות של unordered_map::find(). בדוגמה זו, נוצרת 'מפה לא מסודרת' עם התווים כמפתחות והמספרים השלמים המתאימים כערכים. הפונקציה find() מאתרת את האלמנט המקושר עם המפתח של 'p'. האיטרטור 'ittr' מקושר לאלמנט שנמצא והנתונים שלו מודפסים למסוף. ראה את הקוד הבא:
#include#include <מפה_לא מסודרת>
באמצעות מרחב שמות std ;
int רָאשִׁי ( בָּטֵל ) {
unordered_map < לְהַשְׁחִיר , int > unomp = {
{ 'ב' , 9 } ,
{ 'א' , 6 } ,
{ 'פ' , 8 } ,
{ 'M' , 3 } ,
{ 's' , 4 } } ;
אוטומטי ittr = unomp. למצוא ( 'פ' ) ;
cout << 'איטרטור' ' << ittr->ראשון << ' ' מצביע על = ' << ittr -> שְׁנִיָה << endl ;
לַחֲזוֹר 0 ; }
בואו נחלק את הקוד כדי לקבל הבנה ברורה וטובה יותר שלו:
#include#include <מפה_לא מסודרת>
קבצי הכותרות הדרושים כלולים:
מרחב השמות 'std' מפשט את הקוד. זה מאפשר לך להשתמש באלמנטים מספריית C++ הסטנדרטית מבלי להוסיף להם קידומת 'std::'.
unordered_map < לְהַשְׁחִיר , int > unomp = { { 'ב' , 9 } , { 'א' , 6 } , { 'פ' , 8 } , { 'M' , 3 } , { 's' , 4 } } ;'מפה לא מסודרת' בשם 'um' נוצרת עם התווים ('w', 'a', 'p', 'm', 's') כמקשים והמספרים השלמים המתאימים (9, 6, 8, 3, 4 ) כערכים.
אוטומטי ittr = unomp. למצוא ( 'פ' ) ;הפונקציה find() משמשת לחיפוש האלמנט עם המפתח של 'p' ב-'unordered_map' שהוא 'unomp'. האיטרטור 'ittr' מצביע על האלמנט המזוהה.
cout << 'איטרטור' ' << ittr->ראשון << ' ' מצביע על = ' << ittr -> שְׁנִיָה << endl ;התוכן שאליו מצביע האיטרטור מודפס למסוף. הוא מדפיס את המפתח ('p') ואת הערך המשויך (8) במקרה זה.
לַחֲזוֹר 0 ;התוכנית מסתיימת, ומחזירה 0 כדי לציין ביצוע מוצלח.
הפלט של הקוד ניתן להלן לעיונך:
קוד זה הוא דוגמה פשוטה לשימוש ב-unordered_map::find() כדי לחפש ולגשת ביעילות לאלמנטים בתוך 'unordered_map'. האיטרטור מספק דרך נוחה לגשת גם למפתח וגם לערך המשויך של האלמנט שנמצא.
דוגמה 2:
הנה עוד דוגמה פשוטה לפונקציה unordered_map::find() . קוד זה מדגים את השימוש ב-'unordered_map' לאחסון הערכים הבוליאניים המשויכים למפתחות שלמים ולאחר מכן משתמש בפונקציה find() כדי לבדוק את קיומם של מפתחות ספציפיים. תן לנו לראות את הקוד הבא ואז להבין איך זה עובד:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
unordered_map < int , bool > unomp ;
unomp [ 2 ] = נָכוֹן ;
unomp [ 67 ] = שֶׁקֶר ;
unomp [ ארבע חמש ] = נָכוֹן ;
unomp [ 98 ] = שֶׁקֶר ;
אם ( unomp. למצוא ( 67 ) == unomp. סוֹף ( ) )
cout << 'אלמנט לא נמצא' << endl ;
אַחֵר
cout << 'נמצא אלמנט' << endl ;
אם ( unomp. למצוא ( 42 ) == unomp. סוֹף ( ) )
cout << 'אלמנט לא נמצא' << endl ;
אַחֵר
cout << 'נמצא אלמנט' << endl ;
לַחֲזוֹר 0 ;
}
להלן תיאור מפורט של הקוד:
#includeשורה זו כוללת קובץ כותרת המכסה את ספריות C++ הסטנדרטיות ביותר המשמשות לעתים קרובות בתכנות תחרותי. עם זאת, בפיתוח C++ רגיל, מומלץ לכלול את הכותרות הספציפיות.
unordered_map < int , bool > unomp ;נוצרת מפת 'unordered_map' בשם 'unomp' עם מפתחות שלמים וערכים בוליאניים.
unomp [ 2 ] = נָכוֹן ;unomp [ 67 ] = שֶׁקֶר ;
unomp [ ארבע חמש ] = נָכוֹן ;
unomp [ 98 ] = שֶׁקֶר ;
צמדי המפתח-ערך מוכנסים ל-'unordered_map'. כל מפתח (מספר שלם) משויך לערך בוליאני.
אם ( unomp. למצוא ( 67 ) == unomp. סוֹף ( ) )cout << 'אלמנט לא נמצא' << endl ;
אַחֵר
cout << 'נמצא אלמנט' << endl ;
הפונקציה find() מופעלת במסגרת התנאי if-else כדי לחפש מפתחות ספציפיים (67 ו-42) בתוך ה-'unordered_map'. אם המפתח נמצא, 'Element found' מודפס. אחרת, 'אלמנט לא נמצא' מודפס. ראה את הפלט הבא:
קוד זה מציג את השימוש הבסיסי ב-'unordered_map' ובפונקציה find() כדי לקבוע את נוכחותם או היעדרם של מפתחות ספציפיים במפה.
דוגמה 3:
הבה נחקור דוגמה נוספת המדגימה את מציאת ערך על ידי מתן קלט בזמן ריצה. התוכנית הפשוטה הזו משתמשת ב-'unordered_map' כדי לאחסן את השמות (כמפתחות) וערכים מספריים הקשורים (במקרה זה, המייצגים כמה תכונות). לאחר מכן הוא מבקש מהמשתמש להזין שם, לחפש את השם הזה במפה באמצעות הפונקציה find() ולהדפיס את הערך המשויך אם השם נמצא. הקוד ניתן להלן לעיונך:
#include#include
#include <מפה_לא מסודרת>
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
סטד :: unordered_map < סטד :: חוּט , לְהַכפִּיל > unomp = {
{ 'הרי' , 23 } ,
{ 'אחרים' , 7.4 } ,
{ 'קלסום' , 1.2 } } ;
מחרוזת מי ;
cout << 'את מי אתה מחפש? ' ;
getline ( אֲכִילָה , WHO ) ;
unordered_map < חוּט , לְהַכפִּיל >:: const_iterator fnd = unomp. למצוא ( WHO ) ;
אם ( fnd == unomp. סוֹף ( ) )
cout << 'לא נמצא' ;
אַחֵר
cout << endl << fnd -> ראשון << 'הוא' << fnd -> שְׁנִיָה << endl ;
לַחֲזוֹר 0 ;
}
להלן פירוט הקוד להבנתך:
unordered_map < חוּט , לְהַכפִּיל > unomp = { } ;נוצרת מפת 'unordered_map' בשם 'unomp' עם מקשי מחרוזת (שמות) וערכים כפולים.
מחרוזת מי ;המשתמש מתבקש להזין שם על המסך והקלט מאוחסן במשתנה המחרוזת 'מי'.
unordered_map < חוּט , לְהַכפִּיל >:: const_iterator fnd = unomp. למצוא ( WHO ) ;הפונקציה find() משמשת לחיפוש השם שהוזן ב-'unordered_map'. התוצאה מאוחסנת באיטרטור 'fnd'.
אם ( fnd == unomp. סוֹף ( ) )cout << 'לא נמצא' ;
אַחֵר
cout << endl << fnd -> ראשון << 'הוא' << fnd -> שְׁנִיָה << endl ;
אם האיטרטור 'fnd' מגיע לסוף ה-'unordered_map' (end()), זה אומר שהשם לא נמצא ו'לא נמצא' מודפס. אחרת, השם והערך המשויך לו יודפסו. הנה הפלט של הקוד:
קוד זה פועל למעשה ככלי פשוט לחיפוש שמות באמצעות 'מפה_לא-סדרה'. זה לוקח את קלט המשתמש, מחפש את השם במפה, ומספק את הערך המשויך אם השם נמצא.
סיכום
הפונקציה unordered_map::find() ב-C++ מספקת מנגנון רב עוצמה לאיתור יעיל של האלמנטים בתוך מיכלי 'unordered_map'. מורכבות הזמן הממוצעת הקבועה שלו הופכת אותו לבחירה מועדפת עבור פעולות חיפוש בתרחישים שבהם יש לגשת במהירות לצמדי מפתח-ערך. הדוגמאות שסופקו מציגות את השימוש המעשי שלו, תוך שימת דגש על הפשטות והיעילות שלו. לסיכום, שליטה בפונקציית unordered_map::find() משפרת את היכולת של מתכנת C++ לרתום את מלוא הפוטנציאל של קונטיינרים 'unordered_map', ותורמת ליצירת יישומים אופטימליים ובעלי ביצועים גבוהים.