lecture

1. 1
‫איטרטיבי‬ ‫מיזוג‬ ‫מיון‬
‫ארצי‬ ‫שי‬ ‫של‬ ‫השקפים‬ ‫על‬ ‫מבוסס‬
,
‫גיתית‬
‫רוקנשטיין‬
,
‫איתן‬
‫אביאור‬
,
‫סאהר‬
‫אסמיר‬
,
‫אלעד‬ ‫מיכאל‬
,
‫רביב‬ ‫ודן‬ ‫קימל‬ ‫רון‬
.
‫ע‬ ‫אחרון‬ ‫עדכון‬
"
‫תשפ‬ ‫קיץ‬ ‫ארז‬ ‫יעל‬ ‫י‬
"
‫ב‬

2. 2
‫המצגת‬ ‫נושאי‬
•
‫ממוינים‬ ‫מערכים‬ ‫מיזוג‬
•
‫מיזוג‬ ‫באמצעות‬ ‫מערכים‬ ‫מיון‬

3. 3
‫ממוינים‬ ‫מערכים‬ ‫מיזוג‬
-
Merging
•
‫הנתון‬ ‫הקלט‬
:
‫ממוינים‬ ‫מערכים‬ ‫שני‬
a[]
‫ו‬
-
b[]
‫שאורכיהם‬
na
‫ו‬
-
,nb
‫בהתאמה‬
.
•
‫הרצוי‬ ‫הפלט‬
:
‫אחד‬ ‫ממוין‬ ‫מערך‬
,
c[]
,
‫המערכים‬ ‫מאיברי‬ ‫המורכב‬
a[]
‫ו‬
-
b[]
.
•
‫האלגוריתם‬
:
•
‫מערך‬ ‫לכל‬ ‫אינדקס‬ ‫משתנה‬ ‫נחזיק‬
ic ,ib ,ia
(
‫ל‬ ‫מאותחלים‬
-
0
.)
•
‫את‬ ‫נשווה‬
a[ia]
‫ל‬
-
b[ib]
•
‫הקטן‬ ‫את‬
‫מביניהם‬
‫ב‬ ‫הבא‬ ‫למקום‬ ‫נעתיק‬
-
c[ic]
‫את‬ ‫ונקדם‬
ic
.
•
‫מ‬ ‫איבר‬ ‫לקחנו‬ ‫אם‬
-
a
‫את‬ ‫נקדם‬
ia
.
‫את‬ ‫נקדם‬ ‫אחרת‬
ib
.
•
‫הרשימות‬ ‫אחת‬ ‫לסוף‬ ‫כשנגיע‬
,
‫ל‬ ‫האחרת‬ ‫הרשימה‬ ‫שארית‬ ‫את‬ ‫נעתיק‬
-
c[]
.

4. 4
‫ממוינים‬ ‫מערכים‬ ‫מיזוג‬
–
‫דוגמא‬
16 19 25 48 50 67
14 22 37 45 56 61
14 16 19 22 25 37 45 48 50 56 61 67

5. 5
void merge(int a[], int na, int b[], int nb, int c[]){
int ia, 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];
}
Merge
–
‫מימוש‬
ia = ib = ic = 0;
while (ia < na && ib < nb)
c[ic++] = (a[ia] < b[ib]) ? a[ia++] : b[ib++];
while (ia < na)
c[ic++] = a[ia++];
while (ib < nb)
c[ic++] = b[ib++];

6. 6
‫המיזוג‬ ‫של‬ ‫הזמן‬ ‫סיבוכיות‬
•
‫את‬ ‫מקדמים‬ ‫אנו‬ ‫איטרציה‬ ‫בכל‬
ia
‫או‬
ib
.
•
‫פעולות‬ ‫מספר‬ ‫מבצעים‬ ‫אנו‬ ‫איטרציה‬ ‫בכל‬
(
‫והעתקות‬ ‫השוואות‬
)
‫ע‬ ‫החסום‬
"
‫הקלט‬ ‫בגודל‬ ‫תלוי‬ ‫שאינו‬ ‫קבוע‬ ‫י‬
(
‫סיבוכיות‬
‫קבועה‬
(1)
.)
•
‫היא‬ ‫הזמן‬ ‫סיבוכיות‬ ‫לכן‬
(na + nb)
.
‫המיזוג‬ ‫אלגוריתם‬ ‫של‬ ‫הזמן‬ ‫סיבוכיות‬
‫הינה‬
‫ליניארית‬
‫שלו‬ ‫הקלט‬ ‫בגודל‬
.

7. 7
‫המצגת‬ ‫נושאי‬
•
‫ממוינים‬ ‫מערכים‬ ‫מיזוג‬
•
‫מיזוג‬ ‫באמצעות‬ ‫מערכים‬ ‫מיון‬

8. 8
‫מיזוגים‬ ‫באמצעות‬ ‫מיון‬
:
Merge-Sort
•
‫מערך‬ ‫נתון‬
a[]
‫המכיל‬
n=2k
‫מספרים‬
.
‫המערך‬ ‫את‬ ‫למיין‬ ‫יש‬
‫יורד‬ ‫לא‬ ‫בסדר‬
.
•
‫תתי‬ ‫למזג‬ ‫ביכולתנו‬ ‫נשתמש‬
-
‫הפרופורציונית‬ ‫ליניארית‬ ‫בסיבוכיות‬ ‫סדרות‬
‫במשותף‬ ‫איבריהן‬ ‫לסך‬
.
•
‫האלגוריתם‬
:
•
‫לזוגות‬ ‫המערך‬ ‫את‬ ‫נחלק‬
.
‫זוג‬ ‫כל‬ ‫של‬ ‫פנימי‬ ‫מיון‬ ‫נבצע‬
.
•
‫סמוכים‬ ‫זוגות‬ ‫שני‬ ‫כל‬ ‫נמזג‬
(
‫ממוינים‬
)
‫ממוינת‬ ‫לרביעייה‬
.
•
‫סמוכות‬ ‫רביעיות‬ ‫שתי‬ ‫כל‬ ‫נמזג‬
(
‫ממוינות‬
)
‫ממוינת‬ ‫לשמינייה‬
.
•
...
•
‫באורך‬ ‫ממוינות‬ ‫רשימות‬ ‫שתי‬ ‫נמזג‬
2k-1
‫באורך‬ ‫ממוינת‬ ‫לרשימה‬
2k
.

9. 9
5
2
0 1
6 7
4
3
2
6
0 3
5 4
1
7
‫מיזוג‬ ‫באמצעות‬ ‫מיון‬
–
‫דוגמה‬
2
6
0 3
5 4
1
7
5
2
0 1
6 7
4
3
2
1
0 4
3 7
6
5
‫איטרציה‬
3
‫איטרציה‬
2
5
0
6 7
2 4
1
3
‫איטרציה‬
1

10. 10
‫המחשב‬ ‫למדעי‬ ‫מבוא‬
.
‫שמורות‬ ‫הזכויות‬ ‫כל‬
© 10
‫שלב‬ ‫כל‬ ‫סיבוכיות‬ ‫ניתוח‬
•
‫המוצע‬ ‫האלגוריתם‬ ‫של‬ ‫הזמן‬ ‫סיבוכיות‬ ‫מהי‬
?
•
‫באורך‬ ‫סדרות‬ ‫שתי‬ ‫של‬ ‫מיזוגים‬ ‫הם‬ ‫הבניין‬ ‫אבני‬
2j
‫עם‬
(2j+1)
‫פעולות‬
.
•
‫ה‬ ‫באלגוריתם‬
-
Merge-Sort
:
•
‫שלב‬
1
:
‫על‬ ‫פועלים‬
2k-1
‫באורך‬ ‫רשימות‬
21
‫ב‬ ‫אחת‬ ‫כל‬ ‫ומסדרים‬
-
2
‫פעולות‬
←
‫סך‬
‫של‬
2k
‫פעולות‬
(
=n
.)
•
‫שלב‬
2
:
‫על‬ ‫פועלים‬
2k-2
‫באורך‬ ‫רשימות‬
22
,
‫זוגות‬ ‫שני‬ ‫של‬ ‫כאיחוד‬ ‫נבנית‬ ‫אחת‬ ‫כשכל‬
‫עם‬
(22)
.
‫של‬ ‫סך‬ ‫יידרשו‬ ‫הכול‬ ‫בסך‬
2k
‫פעולות‬
(
=n
.)
•
...
•
‫שלב‬
j
:
‫יוצרים‬
2k-j
‫באורך‬ ‫רשימות‬
2j
,
‫באורך‬ ‫רשימות‬ ‫שתי‬ ‫מיזוג‬ ‫הינה‬ ‫אחת‬ ‫כשכל‬
2j-1
‫סיבוכיות‬ ‫עם‬
(
2j
)

‫ולכן‬
‫של‬ ‫סך‬ ‫יידרשו‬
2k
‫פעולות‬
(
=n
.)
•
‫מסקנה‬
-
‫היא‬ ‫באלגוריתם‬ ‫מהשלבים‬ ‫אחד‬ ‫כל‬ ‫סיבוכיות‬
(n)
.

11. 11
‫המחשב‬ ‫למדעי‬ ‫מבוא‬
.
‫שמורות‬ ‫הזכויות‬ ‫כל‬
© 11
‫סיבוכיות‬ ‫ניתוח‬
Merge-Sort
•
‫כולו‬ ‫המיון‬ ‫כל‬ ‫של‬ ‫הזמן‬ ‫סיבוכיות‬ ‫מהי‬
?
•
‫מספר‬
‫האיטרציות‬
‫באלגוריתם‬
:
k=log2n
‫שלבים‬
‫שבכל‬
‫אחד‬
(2k=n)
‫פעולות‬
.
•
‫סיבוכיות‬
‫היא‬ ‫האלגוריתם‬
:
(k·2k) = (nlog2n)
.
•
‫האלגוריתם‬
Merge-Sort
‫הריבועיים‬ ‫המיון‬ ‫מאלגוריתמי‬ ‫יותר‬ ‫יעיל‬
‫שהכרנו‬
.
•
‫ניתן‬
‫להוכיח‬
(
‫כאן‬ ‫לא‬
)
‫מיון‬ ‫אלגוריתם‬ ‫קיים‬ ‫לא‬ ‫כי‬
,
‫השוואות‬ ‫מבוסס‬
,
‫יותר‬ ‫קטנה‬ ‫זמן‬ ‫סיבוכיות‬ ‫בעל‬
.

12. 12
‫מיזוג‬ ‫באמצעות‬ ‫מיון‬
–
‫איטרטיבי‬ ‫מימוש‬
•
‫הפונקציה‬
merge_sort()
‫מקוננות‬ ‫לולאות‬ ‫משתי‬ ‫מורכבת‬
.
•
‫החיצונית‬ ‫הלולאה‬ ‫משתנה‬
,
len
,
‫שממזגים‬ ‫הרשימות‬ ‫אורך‬ ‫את‬ ‫שומר‬
1,2,4,8, ... ,2(k-1)
.
•
‫הפנימית‬ ‫הלולאה‬ ‫משתנה‬
base
‫הרשימה‬ ‫התחלת‬ ‫כתובת‬ ‫את‬ ‫מחזיק‬
‫למיזוג‬ ‫רשימות‬ ‫זוג‬ ‫בכל‬ ‫הראשונה‬
.
•
‫הפונקציה‬
merge_sort()
‫בפונקציה‬ ‫משתמשת‬
merge()
,
‫פגשנו‬ ‫אותה‬
‫קודם‬
.
•
‫בפונקציית‬ ‫שימוש‬ ‫נעשה‬ ‫גם‬ ‫אנו‬
‫הספריה‬
memcpy
‫מ‬
-
string.h
‫להעתקת‬
‫ידועים‬ ‫ואורך‬ ‫במיקום‬ ‫זיכרון‬ ‫נתח‬
.
‫אחר‬ ‫זמני‬ ‫למערך‬ ‫נעשה‬ ‫שהמיזוג‬ ‫כיוון‬ ‫זאת‬
,
‫המקורי‬ ‫במערך‬ ‫למקומו‬ ‫חזרה‬ ‫להעבירו‬ ‫ויש‬
.

13. 13
Merge Sort
–
‫מימוש‬
int merge_sort(int ar[], int n){
int len;
int *temp_array, *base;
temp_array = (int*)malloc(sizeof(int)*n);
if(temp_array == NULL) {
printf("Dynamic Allocation Error in merge_sort");
return FAILURE;
}
for (len = 1; len < n; len *= 2) {
for (base = ar; base < ar + n; base += 2 * len) {
merge(base, len, base + len, len, temp_array);
memcpy(base, temp_array, 2*len*sizeof(int));
}
}
free(temp_array);
return SUCCESS;
}
RUN

14. 14
‫המחשב‬ ‫למדעי‬ ‫מבוא‬
.
4
Merge-Sort
–
‫גראפית‬ ‫המחשה‬
‫ע‬ ‫האלגוריתם‬ ‫התקדמות‬ ‫דרך‬ ‫את‬ ‫נדגים‬
"
‫סידור‬ ‫י‬
4096
‫בתחום‬ ‫שונים‬ ‫מספרים‬
0-4095
‫התוצאה‬ ‫המחשת‬
‫כגרף‬ ‫איטרציה‬ ‫בכל‬
.
‫כי‬ ‫ניכר‬
:
•
‫מסודרים‬ ‫האיברים‬
‫וגדלים‬ ‫הולכים‬ ‫במקבצים‬
‫ע‬
"
‫תתי‬ ‫מיזוג‬ ‫י‬
-
‫סדרות‬
‫יותר‬ ‫קצרות‬
.
•
‫הנחוצה‬ ‫הצעדים‬ ‫כמות‬
‫הינה‬
12
‫על‬ ‫מעברים‬
‫הנתונים‬
.
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000
0 500 1000 1500 2000 2500 3000 3500 4000
0
500
1000
1500
2000
2500
3000
3500
4000

15. 15
•
‫כזכור‬
:
•
‫בעזרת‬ ‫המיון‬ ‫של‬ ‫הזמן‬ ‫סיבוכיות‬
Merge-Sort
‫הינה‬
(nlog2n)
.
•
‫אותם‬ ‫האחרים‬ ‫באלגוריתמים‬ ‫המיון‬ ‫של‬ ‫הזמן‬ ‫סיבוכיות‬
‫פגשנו‬
(
Max-Sort, Bubble-Sort
)
‫הינה‬
(n2)
.
•
‫לדוגמה‬
,
•
‫מסקנות‬
:
•
‫באלג‬
'
‫ב‬ ‫הכפלה‬ ‫כל‬ ‫הריבועיים‬
-
2
‫פי‬ ‫הכפלה‬ ‫נותנת‬ ‫בכניסה‬
4
‫בסיבוכיות‬
,
•
‫באלג‬
'
‫ה‬
-
Merge-Sort
‫פי‬ ‫הכפלה‬
2
‫מפי‬ ‫יותר‬ ‫מעט‬ ‫של‬ ‫עליה‬ ‫גוררת‬
2
‫בסיבוכיות‬
.
•
‫ה‬
-
Merge-Sort
‫כ‬ ‫פי‬ ‫יעיל‬
-
500
‫עבור‬ ‫הריבועיים‬ ‫שבאלגוריתמים‬ ‫הטוב‬ ‫מול‬
215
n=
.
‫סיבוכיות‬
Merge-Sort
‫המתחרים‬ ‫מול‬
n Bubble-Sort Max-Sort Merge-Sort
215 14 sec 4 sec 0.008 sec
216 55 sec 17 sec 0.016 sec
217 221 sec 69 sec 0.034 sec