דוגמה 1: פרוסת מיון גולנג בסדר עולה
הפונקציה 'sort.Slice()' היא הפונקציה המובילה ב-Go שמסדרת מחדש את רכיבי הפרוסה בסדר עולה או יורד. קח בחשבון את האיור הבא שבו הפרוסה מסודרת בסדר עולה:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'סוג'
)
func רָאשִׁי () {
evenSlice := [] int { 10 , 2 , 8 , 4 , 0 , 6 }
fmt . Println ( 'פרוסה לא ממוינת:' , evenSlice )
סוג . פרוסה ( evenSlice , func ( אני , י int ) bool {
לַחֲזוֹר evenSlice [ אני ] < evenSlice [ י ]
})
fmt . Println ( 'פרוסה ממוינת:' , evenSlice )
}
בתחילת הפונקציה main(), אנו מגדירים את פרוסת evenSlice עם הערכים {10, 2, 8, 4, 0, 6}. פרוסה זו מייצגת אוסף של מספרים זוגיים שאינם ממוינים בתחילה. כדי למיין את פרוסת evenSlice, הפונקציה sort.Slice() מופעלת עם הפרוסה. בתוך הפונקציה sort.Slice(), פונקציית מיון מסופקת כארגומנט. פונקציה זו קובעת את סדר המיון על ידי השוואת שני האלמנטים של הפרוסה במדדים 'i' ו-'j'. אם evenSlice[i] קטן מevenSlice[j], הוא מחזיר true; אחרת, הוא מחזיר false. הפונקציה sort.Slice() משתמשת בפונקציית השוואה זו כדי לארגן מחדש את הרכיבים של פרוסת 'evenSlice' בסדר עולה.
התוצאות של הפרוסה הממוינת בסדר עולה נוצרות במסך הפלט הבא:
דוגמה 2: פרוסת חלק מיון גולנג
לאחר מכן, המיון מוחל על תת הפרוסה של הפרוסה שצוינה בסדר עולה באמצעות הפונקציה sort.Slice() ב-Go.
חֲבִילָה רָאשִׁי
יְבוּא (
'fmt'
'סוג'
)
func רָאשִׁי () {
נ := [] int { 9 , 7 , 3 , 5 }
הַתחָלָה := 0
סוֹף := 3
סוג . פרוסה ( נ [ הַתחָלָה : סוֹף ], func ( אני , י int ) bool {
לַחֲזוֹר נ [ הַתחָלָה + אני ] < n [ הַתחָלָה + י ]
})
fmt . Println ( נ )
}
בתחילה, אנו יוצרים את הפרוסה 'n' עם הערכים [9, 7, 3, 5]. בנוסף, שני משתנים, 'התחלה' ו'סוף', מוגדרים ל-0 ו-3, בהתאמה. משתנים אלו מגדירים את טווח המדדים בפרוסת 'n' שתמוין. לאחר מכן, הפונקציה 'sort.Slice()' נקראת עם תת הפרוסה 'n[start:end]' בתור הארגומנט הראשון. תת פרוסה זו מכילה את הרכיבים של 'n' בטווח שצוין. לאחר מכן, ניתנת פונקציית מיון כארגומנט השני בתוך הפונקציה sort.Slice().
כאן, פונקציה זו מקבלת שני מדדים, 'i' ו-'j', המייצגים את האלמנטים בתוך הפרוסה. כדי להשוות את האלמנטים בתוך הפרוסה, פונקציית המיון ניגשת לרכיבים המתאימים בפרוסה המקורית באמצעות ההתחלה offset. הוא משווה את ה-n[start+i] ו-n[start+j]. לאחר מכן, הפונקציה sort.Slice() משתמשת בפונקציית המיון המסופקת כדי לסדר מחדש את האלמנטים בתוך הפרוסה המשנה בסדר עולה.
הפלט הבא מציג שהרכיבים בטווח שצוין (התחל עד סוף-1) ממוינים, והאלמנטים מחוץ לטווח נשארים ללא שינוי:
דוגמה 3: גולנג מיון פרוסת מספר שלם באמצעות הפונקציה Sort.Ints()
יתרה מכך, הכי נוח למיין את פרוסות המספרים השלמים הוא הפונקציה sort.Ints() ללא צורך ביישום שיטות המיון המותאמות אישית. הוא פועל ישירות על פרוסות שלמות ומבצע מיון במקום. התוכנית הבאה ממיינת את המספרים השלמים שצוינו:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'סוג'
)
func רָאשִׁי () {
IntSlice := [] int { 10 , 13 , חֲמֵשׁ עֶשׂרֵה , אחד עשר , 14 , 12 }
fmt . Println ( 'פרוסה לא ממוינת:' , IntSlice )
סוג . Ints ( IntSlice )
fmt . Println ( 'פרוסה ממוינת:' , IntSlice )
}
ראשית, אנו מצהירים ומאתחלים את הפרוסה 'IntSlice' עם הערכים [10, 13, 15, 11, 14, 12] המייצגים אוסף של מספרים שלמים שאינם ממוינים בתחילה. לאחר מכן, הפונקציה sort.Ints() נקראת עם הפרוסה 'IntSlice' כארגומנט למיין את 'IntSlice'. הפונקציה sort.Ints() במקרה זה ממינת באופן פנימי כל חלק של הפרוסה לפי אלגוריתם מיון אופטימלי. הוא משנה את הפרוסה המקורית ישירות, מסדר מחדש את האלמנטים שלו לסדר ממוין.
הפלט הבא מראה תחילה שהפרוסה הלא ממוינת מוצגת תחילה, ואחריה הפרוסה הממוינת:
דוגמה 4: פרוסת מחרוזת מיון גולאנג
Go מציעה גם את הפונקציה sort.Strings() של חבילת המיון המשמשת למיון פרוסת מחרוזות בסדר מסוים. כאן, התוכנית הבאה מסייעת למיין את פרוסת המיתרים:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'סוג'
)
func רָאשִׁי () {
strSl := [] חוּט { 'גולן' , 'פִּיתוֹן' , 'ג'אווה' , 'פרל' , 'כתב כתיבה' }
סוג . מחרוזות ( strSl )
fmt . Println ( strSl )
}
תחילה הקמנו את הפרוסה 'strSl' עם ערכי ['golang', 'python', 'java', 'perl', 'typescript'] שאינם ממוינים. לאחר מכן, נמיין את הפרוסה 'strSl' עם הפונקציה sort.Strings() שממיינת את הרכיבים של הפרוסה בסדר לקסיקוגרפי. פונקציה זו משנה את הפרוסה המקורית באופן ישיר, ומסדרת מחדש את הרכיבים שלה בסדר ממוין בהתבסס על ערכי ה-ASCII שלהם.
הפלט ממיין את פרוסת המחרוזת באופן עולה כפי שמוצג בקטע הבא:
דוגמה 5: Golang Check Sort Slice באמצעות הפונקציה IntAreSort()
עם זאת, עם הפונקציה sort.IntsAreSorted() של Go, נוכל לבדוק אם פרוסה נתונה של מספרים שלמים ממוינת בסדר עולה או לא. שקול את התוכנית הבאה לדוגמה של הפונקציה IntAreSort() עבור הפרוסה הנתונה:
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'סוג'
)
func רָאשִׁי () {
sl := [] int { - 33 , 105 , - 42 , 59 , 18 , 0 , - 3 }
fmt . Println ( 'פרוסות:' )
fmt . Println ( 'פרוסה לא ממוינת:' , sl )
תוֹצָאָה := סוג . IntsAreSorted ( sl )
fmt . Println ( ' \n תוֹצָאָה:' )
fmt . Println ( 'האם נתון Slice ממוין?:' , תוֹצָאָה )
}
ראשית, פרוסה לא ממוינת של מספרים שלמים אקראיים מוגדרת כ'sl'. פרוסה זו מכילה אוסף של מספרים שלמים ללא סדר מסוים. לאחר מכן, אנו קוראים לפונקציה sort.IntsAreSorted() ומעבירים את פרוסת 'sl' כארגומנט. פונקציה זו מספקת תוצאה בוליאנית שמציינת אם קלט הפרוסה מסודר בסדר עולה או לא. לאחר מכן, הפונקציה fmt.Println() מדפיסה את התוצאות שמוציאות אם הפרוסה הנתונה ממוינת או לא בהתבסס על הערך הבוליאני המוחזר.
הפלט מציג false עבור סדר המיון של פרוסת מספרים שלמים כשהוא לא ממוין:
דוגמה 6: פרוסת מיון הפוך של גולנג
יתרה מכך, באמצעות הפונקציות sortReverse() ו- sortStringSlice() מחבילת המיון ב-Go, נוכל למיין לאחור פרוסת מחרוזות. התוכנית הבאה מדגימה את פעולת הפונקציה sort.Reverse() :
חֲבִילָה רָאשִׁייְבוּא (
'fmt'
'סוג'
)
func רָאשִׁי () {
vowelSlice := [] חוּט { 'זה' , 'א' , 'אני' , 'ב' , 'או' }
fmt . Println ( 'לפני מיון:' , vowelSlice )
סוג . סוג ( סוג . לַהֲפוֹך ( סוג . StringSlice ( vowelSlice )))
fmt . Println ( 'לאחר מיון :' , vowelSlice )
}
נתחיל בהגדרת פרוסה של מחרוזת 'vowelSlice' המכילה את התנועות 'e', 'a', 'i', 'u' ו-'o'. התוכן הראשוני של פרוסת המחרוזות שצוינה מודפס תחילה באמצעות הפונקציה 'הדפסה'. לאחר מכן, פעולת המיון מתבצעת באמצעות הפונקציה sort.Sort() עם הפונקציות sort.Reverse() ו- sort.StringSlice() כארגומנטים. כאן, ה-'sort.Reverse()' יוצר סוג חדש שהופך את סדר האלמנטים. זה לוקח את הסוג 'sort.StringSlice' כארגומנט שלו אשר ממיר את vowelSlice לסוג שניתן למיין.
הפלט כאן מציג את התנועות בסדר אלפביתי הפוך:
סיכום
התעמקנו בפונקציות מיון שונות עם דוגמאות הממיינות את הפרוסה שסופקה. סיקרנו גם על מיון של תת פרוסות ובדיקה אם פרוסה כבר ממוינת. לפיכך, אנו יכולים למנף את היכולות של חבילת המיון להתמודדות עם מגוון רחב של אתגרי מיון בפרויקטי ה-Go שלהם.