תרגול 13: אלגוריתמי מיון, שאלות ממבחנים

1. תרגול 13: אלגוריתמי מיון, שאלות ממבחנים

2. מה היה שבוע שעבר? • backtracking מבוא למדעי המחשב מ' - תירגול13

3. והיום נלמד • Max sort • Bubble sort • Merge sort • Quick sort • שאלות ממבחנים העוסקות במיון מבוא למדעי המחשב מ' - תירגול13

4. אלגוריתמי מיון מבוא למדעי המחשב מ' - תירגול13

5. אלגוריתמי מיון – מוטיבציה • קיימים סוגים רבים של אלגוריתמי מיון. • למה בעצם אנחנו כל-כך רוצים למיין באופן יעיל? • שאילתות רבות - שמירת נתונים ממוינים מאפשרת חיפוש מהיר. מבוא למדעי המחשב מ' - תירגול13 6

6. Max Sort - תזכורת • מוצאים את המקסימום במערך ומעבירים אותו לסוף. • חוזרים על התהליך בקטע המערך שעדיין לא מיינו, כלומר באיטרציהi נבצע את התהליך על קטע 0..n-i-1.דוגמא, איטרציהמס' 2 (מתחילים מ – 0): Not sorted 45 56 61 14 37 22 22 37 14 61 56 sorted מבוא למדעי המחשב מ' - תירגול13

7. Max Sort - תזכורת • מוצאים את המקסימום במערך ומעבירים אותו לסוף. • חוזרים על התהליך בקטע המערך שעדיין לא מיינו, כלומר באיטרציהi נבצע את התהליך על קטע 0..n-i-1.דוגמא, איטרציהמס' 2 (מתחילים מ – 0): Not sorted Maximum! 56 61 14 37 22 22 37 14 61 56 45 sorted מבוא למדעי המחשב מ' - תירגול13

8. Max Sort - תזכורת • מוצאים את המקסימום במערך ומעבירים אותו לסוף. • חוזרים על התהליך בקטע המערך שעדיין לא מיינו, כלומר באיטרציהi נבצע את התהליך על קטע 0..n-i-1.דוגמא, איטרציה מס' 2 (מתחילים מ – 0): ניתן לממש בלולאה או ברקורסיה. מה עדיף? Not sorted 37 45 56 61 14 37 22 22 14 61 56 Maximum! sorted מבוא למדעי המחשב מ' - תירגול13

9. Max Sort – מימוש בלולאה מההרצאה intindex_of_max(int a[], int n) { int i, i_max = 0; for(i = 1; i < n; i++) if(a[i] > a[i_max]) i_max = i; return i_max; } void max_sort(int a[], int n) { int length; for(length = n ; length > 1; length--) { int i_max = index_of_max(a, length); swap(&a[length-1], &a[i_max]); } }

10. Max Sort – מימוש ברקורסיה void max_sort(int a[], int n) { if (n==1) return; inti_max = index_of_max(a, n); swap(&a[n-1], &a[i_max]); max_sort(a, n-1); } אז מה עדיף...? בלולאה: סיבוכיות זמן: . סיבוכיות מקום נוסף: O(1) ברקורסיה: סיבוכיות זמן: . סיבוכיות מקום נוסף: O(n)

11. Bubble Sort - תזכורת • בכל איטרציה עוברים על המערך ומחליפים בין איברים צמודים אשר נמצאים בסדר לא נכון (כלומר a[i]>a[i+1]). • מסיימים אחרי איטרציה אשר לא דרשה החלפות. • כמה איטרציות יהיו לכל היותר? • איטרציה לדוגמא: < 45 22 56 14 37 22 37 14 61 56 61 מבוא למדעי המחשב מ' - תירגול13

12. Bubble Sort - תזכורת • בכל איטרציה עוברים על המערך ומחליפים בין איברים צמודים אשר נמצאים בסדר לא נכון (כלומר a[i]>a[i+1]). • מסיימים אחרי איטרציה אשר לא דרשה החלפות. • כמה איטרציות יהיו לכל היותר? • איטרציה לדוגמא: > < 45 22 56 37 22 37 14 61 56 14 61 מבוא למדעי המחשב מ' - תירגול13

13. Bubble Sort - תזכורת • בכל איטרציה עוברים על המערך ומחליפים בין איברים צמודים אשר נמצאים בסדר לא נכון (כלומר a[i]>a[i+1]). • מסיימים אחרי איטרציה אשר לא דרשה החלפות. • כמה איטרציות יהיו לכל היותר? • איטרציה לדוגמא: < 45 22 56 61 37 22 14 61 56 14 37 מבוא למדעי המחשב מ' - תירגול13

14. Bubble Sort - תזכורת • בכל איטרציה עוברים על המערך ומחליפים בין איברים צמודים אשר נמצאים בסדר לא נכון (כלומר a[i]>a[i+1]). • מסיימים אחרי איטרציה אשר לא דרשה החלפות. • כמה איטרציות יהיו לכל היותר? • איטרציה לדוגמא: < 45 22 56 37 22 14 61 56 14 37 מבוא למדעי המחשב מ' - תירגול13

15. Bubble Sort - תזכורת • בכל איטרציה עוברים על המערך ומחליפים בין איברים צמודים אשר נמצאים בסדר לא נכון (כלומר a[i]>a[i+1]). • מסיימים אחרי איטרציה אשר לא דרשה החלפות. • כמה איטרציות יהיו לכל היותר? • איטרציה לדוגמא: 45 22 56 61 37 22 14 56 14 37 מבוא למדעי המחשב מ' - תירגול13

16. Bubble Sort - תזכורת • לכל היותר n-1איטרציות: • בסיום האיטרציה ה – i, i המספרים הגדולים במערך יהיו במיקומם הנכון • כמו בדוגמא, המקסימום 61, "בעבע" כל הדרך לסוף המערך. • מסקנות: • סיבוכיות זמן bubble sort: • בכל איטרציהi מספיק להריץ עד אינדקס n-i-1. • סיבוכיות מקום נוסף O(1). מבוא למדעי המחשב מ' - תירגול13

17. Bubble Sort – מימוש מההרצאה int bubble(int a[], int n) { inti, swapped = 0; for(i = 1; i < n; i++) if(a[i-1] > a[i]) { swap(&a[i], &a[i-1]); swapped = 1; } return swapped; } void bubble_sort(int a[], int n) { intnot_sorted = 1; while( (n > 1) && not_sorted ) not_sorted = bubble(a, n--); }

18. שאלה מתוך מועד ב' חורף 2012 • בשאלה זו נניח כי המערך a[]הוא כזה שבו החלפה של שני איברים (באמצעות הפונקציה swap) תלויה במרחק ביניהם. • ספציפית, החלפת האיבר a[i] והאיבר a[j] לוקחת פעולות, במקום O(1) כפי שהנחנו עד כה. שימו לב שיתר הפעולות על המערך נותרות ללא שינוי, ובפרט, השוואה של שני איברים לוקחת O(1)בלבד (כרגיל). • עבור מערך מהסוג המתואר, מה תהיה סיבוכיות הזמן של אלגוריתמי המיון max sort, bubble sort? ולאור זאת, איזה מבין שני האלגוריתמים עדיף במצב זה (מבחינת סיבוכיות זמן)? מבוא למדעי המחשב מ' - תירגול13

19. שאלה מתוך מועד ב' חורף 2012 • Max sort: החלפות מתבצעות בין האיבר המקסימלי במערך לבין האיבר האחרון. כאשר האיבר המקסימלי נמצא בתחילת המערך, החלפה תדרוש פעולות. • באלגוריתם max sort מתבצעות n-1איטרציות, בכל איטרציהi מוצאים את המקסימום: O(n-i), ומחליפים בין המקסימום לאיבר באינדקס n-i-1, בסיבוכיות . • סה"כ: מבוא למדעי המחשב מ' - תירגול13

20. שאלה מתוך מועד ב' חורף 2012 • Bubble sort: באלגוריתם מיון בועות, החלפה בין שני איברים במערך מתבצעת רק בין שני איברים סמוכים זה לזה, ולכן המערך מהסוג המתואר לא משפיע על הסיבוכיות הידועה של האלגוריתם, כלומר: . • לפיכך, האלגוריתם העדיף הוא bubble sort. מבוא למדעי המחשב מ' - תירגול13

21. Merge Sort - תזכורת • ממיינים רקורסיבית את חצאי המערך. • ממזגים בין החצאים הממוינים – מכאן השם "מיון מיזוג". • דוגמא: מבוא למדעי המחשב מ' - תירגול13

22. Merge Sort - תזכורת • דוגמא-המשך: merge merge merge merge merge מבוא למדעי המחשב מ' - תירגול13

23. Merge Sort – מימוש מיזוג מערכים void merge(int a[], intna, int b[], intnb, int c[]) { intia, ib, ic; for(ia = ib = ic = 0; (ia < na) && (ib < nb); ic++) { if(a[ia] < b[ib]) { c[ic] = a[ia]; ia++; } else { c[ic] = b[ib]; ib++; } } for(;ia < na; ia++, ic++) c[ic] = a[ia]; for(;ib < nb; ib++, ic++) c[ic] = b[ib]; } הפונקציה ממזגת בין a,b מערכים ממוינים, והתוצאה נשמרת במערך c. גדלי המערכים נתונים כפרמטרים.

24. Merge Sort – מימוש מיון מיזוג רקורסיבית void merge_sort(int a[], int n) { int *tmp_array = malloc(sizeof(int) * n); internal_msort(a, n, tmp_array); free(tmp_array); } void internal_msort(int a[], int n, int helper_array[]) { int left = n / 2, right = n – left; if (n < 2) return; internal_msort(a, left, helper_array); internal_msort(a + left, right, helper_array); merge(a, left, a + left, right, helper_array); memcpy(a, helper_array, n * sizeof(int)); }

25. Merge Sort - סיבוכיות • בכל שלב מבצעים O(n) פעולות, וקוראים רקורסיבית לפונקציה עם מערך בגודל n/2. • סיבוכיות זמן ריצה ניתנת ע"י נוסחת הנסיגה: T(n)=2T(n/2)+O(n) כאשר T(1)=O(1). • לכן, סיבוכיות זמן של מיון מיזוג: . • סיבוכיות מקום נוסף: O(n) – כיוון שאנו מקצים מערך עזר בגודל n, ועומק הרקורסיה הוא log n: O(n+log n)=O(n) מבוא למדעי המחשב מ' - תירגול13

26. Quick Sort • בוחרים "pivot" באקראי. • מסדרים את המערך כך שכל האיברים הגדולים מ – pivot יהיו אחריו, וכל האיברים הקטנים ממנו לפניו. • אחרי פעולה זו, pivot יהיה במיקומו הנכון המערך, אך האיברים הקטנים או הגדולים ממנו עלולים להיות מבולגנים באזור שלהם. • ממיינים רקורסיבית את כל אחד מחלקי המערך באותו אופן. מבוא למדעי המחשב מ' - תירגול13

27. Quick Sort - מימוש • לאחר בחירת ה – pivot, נחליף אותו עם האיבר הראשון במערך. • נסרוק את המערך משני הכיוונים, ונשווה כל איבר לערך ה – Pivot. • אם בכיוון מההתחלה לסוף מצאנו איבר גדול מה – pivot, נחפש בכיוון השני (מהסוף להתחלה) איבר קטן מה – Pivot ונחליף ביניהם. מבוא למדעי המחשב מ' - תירגול13

28. Quick Sort - מימוש • לאחר בחירת ה – pivot, נחליף אותו עם האיבר הראשון במערך. • נסרוק את המערך משני הכיוונים, ונשווה כל איבר לערך ה – Pivot. • אם בכיוון מההתחלה לסוף מצאנו איבר גדול מה – pivot, נחפש בכיוון השני (מהסוף להתחלה) איבר קטן מה – Pivot ונחליף ביניהם. • אם אין כזה, סיימנו, ואפשר לשים את pivot מיקומו הנכון. מבוא למדעי המחשב מ' - תירגול13

29. Quick Sort – מימוש voidquick_sort(int a[], int n) { int p, b = 1, t = n - 1; if (n < 2) return; swap(&a[0], &a[n/2]); p = a[0]; while(b <= t) { while(t >= b && a[t] >= p ) t--; while(b <= t && a[b] < p) b++; if ( b < t) swap(&a[b++], &a[t--]); } swap(&a[0], &a[t]); quick_sort(a, t); quick_sort(a + t + 1, n – t - 1); }

30. Quick Sort - סיבוכיות • הסיבוכיות של quick sort במקרה הממוצע היא . • במקרה הגרוע מדובר בסיבוכיות ריצה של (למשל אם כל פעם ה – pivot שנבחר יהיה האיבר המינימלי). • סיבוכיות מקום – במקרה הממוצע O(log n), במקרה הגרוע O(n). מבוא למדעי המחשב מ' - תירגול13

31. אלגוריתמי מיון - סיכום • למדנו מספר שיטות מיון. האלגוריתמים השונים הם בעלי מאפיינים שונים: • בהינתן בעיית מיון, נבחר את אלגוריתם המיון המתאים לבעיה עפ"י המאפיינים שלו, כפי שנראה בדוגמאות בהמשך. מבוא למדעי המחשב מ' - תירגול13

32. שאלה מתוך מועד א' אביב 2013 • ממשו את הפונקציה הבאה, שחתימתה: intlimit_and_sort(int a[], int n, int m, int p[]); • הפונקציה מקבלת כקלט מערך a של מספרים שלמים וחיוביים באורךn, עוד מספר m>1 וכן מצביע p למערך של לפחות mתאים (המערך כבר מוקצה). על הפונקציה למצוא את כל המספרים ב – a שערכם לכל היותר m ולכתוב אותם בצורה ממוינת ובלי חזרות למערך p. • על הפונקציה להחזיר את מספר המספרים שנכתבו ל- p. לדוגמא, אם a הוא המערך הבא: int a[7] = {4, 7, 5, 4, 3, 30, 201}; וכן n=7, m=200, אז על הפונקציה לכתוב לתוך 5 התאים הראשונים של המערך p את התוכן הבא (משמאל לימין): וכן להחזיר את המספר 5 . • דרישות: סיבוכיות זמן O(m+n) וסיבוכיות מקום נוסף O(m) מבוא למדעי המחשב מ' - תירגול13

33. שאלה מתוך מועד א' אביב 2013 • עלינו למיין בסיבוכיות זמן של O(m+n). • אלגוריתמי המיון שהכרנו לא עומדים בסיבוכיות הזו. עלינו להשתמש בעובדה שהמספרים שאנו רוצים למיין חסומים בתחום 1 עד m, ובסיבוכיות המקום הנוסף בו מותר לנו להשתמש - O(m). • נוכל לשמור מערך באורך m, כך שבמקום ה – i נשמור את מספר המופעים של i במערך המקורי. בסוף נוכל לעבור על המערך ולהחזיר את המספרים לפי הסדר. במקרה הזה אין חזרות, אז אין צורך לשמור את מספר המופעים אלא רק 1 או 0. • הערה: זה למעשה מקרה פרטי של מיון נפוץ אשר נקרא bucket sort. מבוא למדעי המחשב מ' - תירגול13

34. שאלה מתוך מועד א' אביב 2013 intlimit_and_sort(int a[], int n, int m, int p[]) { intexists[m+1]; for (int i=1; i <= m; i++) // initialize exists ??? // Build exists for (int i=0; i<n; i++) ??? // Fill p[] intnum=0; for (int i=1; i <= m; i++) ??? return num; } מבוא למדעי המחשב מ' - תירגול13

35. שאלה מתוך מועד א' אביב 2013 intlimit_and_sort(int a[], int n, int m, int p[]) { intexists[m+1]; for (int i=1; i <= m; i++) exists[i] = 0; // Build indicator array for (int i=0; i<n; i++) if (a[i] <= m) exists[a[i]] = 1; // Fill p[] intnum=0; for (int i=1; i <= m; i++) if (exists[i]) p[num++]=i; return num; } מבוא למדעי המחשב מ' - תירגול13

36. שאלה מתוך מועד א' חורף 2013/14 • בממלכה רחוקה ישנן N ערים, ובכל עיר בדיוק K תושבים (כאשרN ו-K מוגדרים כ-#define).בממלכה קיימת מערכת גביית מיסים המאחסנת את הנתונים הבאים: המערך a[N]מכיל את סכומי המס שמשלמת כל עיר, כאשר a[i]הוא הסכום שמשלמת העיר ה-i.המערך id[N][K]מכיל את מספרי תעודת הזהות של תושבי כל עיר, כאשר השורה ה- i של המערך, id[i][0..K-1]מכילה את מספרי תעודת הזהות של התושבים בעיר ה- i. • בשאלה זו נרצה לכתוב פונקציה הממיינת את הערים על פי סכום המס שהן משלמות, בסדר עולה. עליכם לממש פונקציה (בעמוד הבא) המקבלת את המערכים aו- id, וממיינת אותם כך שלאחר המיון המערך aיהיה בסדר עולה. בתהליך זה יש לשמור על ההתאמה בין המערכים, כלומר, גם לאחר המיון השורה ה- i במערך idצריכה להכיל את רשימת התושבים בעיר שמשלמת מס בגובה a[i]. מבוא למדעי המחשב מ' - תירגול13

37. שאלה מתוך מועד א' חורף 2013/14 • הגרסה המקוצרת: ברשותנו מערכים a[N]ו - id[N][K]. עלינו למיין את מערך a בסדר עולה, וכמו כן לשנות את הסדר במערך id לפי a. • אם לאחר מיון a, הפריט באינדקס i עבר לאינדקס j, אז: new_id[j]=old_id[i]. • דרישות סיבוכיות: כיוון שבסבירות גבוהה K גדול מ – N, נרצה סיבוכיות קטנה ככל האפשר ביחס ל- K. לפיכך, דרישות הסיבוכיות הינן: זמן , זיכרון נוסף O(1). מבוא למדעי המחשב מ' - תירגול13

38. שאלה מתוך מועד א' חורף 2013/14 • באיזה אלגוריתם מיון עדיף להשתמש? נבחר בהתאם לדרישות הסיבוכיות. • נשים לב שחילוף בין שתי שורות במערך id יהיה בסיבוכיות זמן O(K). לכן, מותר לנו לבצע O(N) חילופים כאלה. • באיזה אלגוריתם מיון יש O(N) חילופים? • Max Sort! מבוא למדעי המחשב מ' - תירגול13

39. שאלה מתוך מועד א' חורף 2013/14 • במימוש בוודאי נצטרך לבצע חילופים בין פריטים במערך a, וכמו כן לבצע חילופים בין שורות במטריצה id: void swap(int *a, int *b) { inttmp=*a; *a=*b; *b=tmp; { void swap_rows(int k, int town1[], int town2[]) { for(inti=0;i<k; ++i) swap(town1+i, town2+i); { מבוא למדעי המחשב מ' - תירגול13

40. שאלה מתוך מועד א' חורף 2013/14 • נשלים את מימוש המיון עצמו: void sort(int a[], int id[][K]) { for(inti=N; i>1; i--) { intmax=find_max_idx(a, i); swap(a+max, a+i-1); swap_rows(K, id[max], id[i-1]); { { intfind_max_idx(int a[], int n) { intmax = 0; for(inti=1; i<n; ++i) if(a[i]>a[max]) max=i; return max; { מבוא למדעי המחשב מ' - תירגול13

41. שאלה מתוך מועד א' חורף 2013/14 • סיבוכיות של swap: • O(1). • סיבוכיות של swap_rows: • O(k)כיוון שיש לולאה עם kאיטרציות, כל איטרציהO(1). • סיבוכיות של find_max_idx: • O(n)כיוון שיש לולאה עם nאיטרציות, כל איטרציהO(1). • סיבוכיות של sort: Nאיטרציות, בכל איטרציה: • קריאה ל – find_max_idx ב - O(i)<=O(N). • קריאה ל – swap ב – O(1). • קריאה ל – swap_rows ב – O(K). • סה"כ O(N(N+K)) כנדרש  מבוא למדעי המחשב מ' - תירגול13

42. שאלה מתוך מועד ב' חורף 2013/14 • נתון מערך s[] של מחרוזות, כאשר ידוע שכל המחרוזות בו בעלות אורך של לכל היותר m. שימו לב שבסעיף זה ייתכנו כמה מחרוזות בעלות אותו האורך במערך s. עליכם לממש פונקציה המקבלת את המערך s, את אורכו n, וכן את אורך המחרוזת המקסימאלית m, וממיינת את s בסדר עולה לפי אורך המחרוזת. למשל, עבור המערך הבא: char* s[] = { "abcde", "aa", "bc", "234114" }; הפונקציה צריכה למיין מחדש את s באופן הבא: char* s[] = { "aa", "bc", "abcde", "234114" }; שימו לב שאין חשיבות לסדר בין מחרוזות שאורכן זהה. מבוא למדעי המחשב מ' - תירגול13

43. שאלה מתוך מועד ב' חורף 2013/14 • דרישות סיבוכיות: על הפונקציה לעמוד בסיבוכיות זמן O(n*m) וסיבוכיות מקום O(n+m). • ניתן להשתמש בפונקציית עזר המחזירה אורך של מחרוזת: intstrlen(char* str); מבוא למדעי המחשב מ' - תירגול13

44. שאלה מתוך מועד ב' חורף 2013/14 void sort(char* s[], int n, int m) { char *helper[n]; int lengths[n], curr=0; for(inti=0; i<n; ++i) { helper[i]=s[i]; lengths[i]=strlen(s[i]); } for(int k=0; k<=m; ++k)//for each length for(inti=0; i<n; ++i) //copy strings of length k to s { if(lengths[i]==k) s[curr++]=helper[i]; } } מבוא למדעי המחשב מ' - תירגול13

45. שאלה מתוך מועד א' חורף 2008 • נתונים שני מערכים מטיפוס Int: מערך a באורך na ומערך b באורך nb. נניח כי na<=nb, ושבכל מערך בפני עצמו אין חזרות. • יש לממש פונקציה אשר מקבלת את שני המערכים ואת גודלם, ומחזירה את מספר הערכים אשר מופיעים גם ב – a וגם ב – b (כלומר גודל קבוצת החיתוך). לדוגמא עבור המערכים: הפונקציה תחזיר 2. ניתן להשתמש בפונקציות שנלמדו בכיתה. מבוא למדעי המחשב מ' - תירגול13

46. שאלה מתוך מועד א' חורף 2008 • הפונקציה צריכה להיות בסיבוכיות זמן קטנה ככל הניתן, יש לחסוך גם בסיבוכיות מקום אך לא על חשבון סיבוכיות הזמן. • ניתן בקלות לפתור את השאלה בסיבוכיות O(na*nb) – בלולאה מקוננת, עבור כל זוג איברים a[i], b[j] נבדוק האם הם שווים. • האם ניתן לשפר את סיבוכיות הזמן? מבוא למדעי המחשב מ' - תירגול13

47. שאלה מתוך מועד א' חורף 2008 • בפתרון שהצענו, לחפש את a[i] במערך b ייקח O(nb) פעולות. • נוכל לייעל את החיפוש אם נמיין את אחד המערכים, ונחפש בעזרת חיפוש בינארי בסיבוכיות זמן O(log n). • באיזה מיון נרצה להשתמש? איזה מהמערכים עדיף למיין? • המיון הכי יעיל שאנו מכירים, merge-sort בסיבוכיות O(n*log n). נשווה בין האפשרויות שלנו: • מיון a: O(na*log na), אח"כ נעבור על מערך b ונחפש כל איבר ב – a. סה"כ: O(na*log na + nb*log na)=O(nb*log na). • מיון b: O(nb*log nb), אח"כ נעבור על מערך aונחפש כל איבר ב – b. סה"כ: O(nb*log nb+ na*log nb)=O(nb*log nb). The chosen one! מבוא למדעי המחשב מ' - תירגול13

48. שאלה מתוך מועד א' חורף 2008 • int intersect(int a[], int b[], intna, intnb) • { • inti, count=0; • merge_sort(a, na); • for (i=0; i<nb; i++) • } • if (binary_search(a, na, b[i])) • count++; • } • return count; • } מבוא למדעי המחשב מ' - תירגול13

49. שאלה מתוך מועד ב' חורף 2008 • יש למיין מערך "מיוחד" של מספרים שלמים. גודל המערך הוא k+m, כאשר k האיברים הראשונים, במקומות 0..k-1, מאוחסנים בזיכרון איטי לכתיבה, ושאר המערך מאוחסן בזיכרון רגיל. • בעצם עלינו לבצע מספר מינימלי של פעולות כתיבה ל – k האיברים הראשונים במערך. סיבוכיות הזמן הכוללת של המיון צריכה להיות גם היא יעילה ככל הניתן, אך לא על חשבון מספר קטן של כתיבות לזיכרון האיטי. • סיבוכיות מקום נדרשת: O(m) מבוא למדעי המחשב מ' - תירגול13

50. שאלה מתוך מועד ב' חורף 2008 • void sort_mixed(int a[], int k, int m) { • inti; • // the following loop performs “min sort” of • // only k iterations • for (i=0; i<k; i++) • { • intmin_ind = find_min(a+i,k+m-i); //members in place. • swap(&a[i], &a[min_ind]); • } • mergesort(a+k, m); • { מספר כתיבות לזיכרון איטי: k. סיבוכיות: O(k*(k+m)+m*log m) We can do better… מבוא למדעי המחשב מ' - תירגול13