מבוא למחשב בשפת Matlab

מבוא למחשב בשפת Matlab הרצאה 13: מיון על ידי מיזוג. הרצאה 12: נכתב על-ידי שלמה מורן, מבוסס על שקפים שלאיתן אביאור, ראובן בר יהודה וסילביו מיקלי.

תזכורת: חסם תחתון על מספר ההשוואות הדרוש למיון. • ניתן להראות שכל אלגוריתם למיון של n אברים חייב לבצע לפחות כ [nlog(n)-n] השוואות. עבור 1,000,000 מדובר בכ 20,000,000 השוואות בלבד (יחסית ל500 מיליארד השוואות הנדרשות על ידי שני האלגוריתמים שראינו בשיעור שעבר). • השאלה הבאה המתבקשת: האם קיים אלגוריתם למיון המסתפק ב nlog(n) השוואות? • תשובה: כן. למשל האלגוריתם מיון על ידי מיזוג שנלמד היום. מבוא למדעי המחשב במטלאב

מיון מיזוג • מיון מיזוג (Merge Sort)הוא שיטה למיון סדרה על ידי מיזוג תת סדרות ממוינות שלה. • האלגוריתם משמש בפונקציה למיזוג מערכים ממוינים, הדורשת לכל היותר m+n-1 השוואות למיזוג מערכים ממוינים שאורכיהם m,n בהתאמה. • בשלב ראשון, נגדיר את "בעיית המיזוג" ונכתב אלגוריתם יעיל לפתרונה. מבוא למדעי המחשב במטלאב

בעיית המיזוג • קלט: שני מערכים ממוינים של מספרים: A בגודל m ו B בגודל n. • פלט: מערך ממוין C בגודל m+n המכיל את אברי A ו B. • מגבלה: מותר להשתמש בהשוואות בלבד. • אלגוריתם: נבנה את C ע"י סריקת המערכים A,B, מהקטן לגדול, באופן הבא: • כל זמן שלא הגענו לסוף A או לסוף B, נעתיק ל C את האיבר היותר קטן מבין האיברים הבאים ב A וB, ונתקדם לאבר הבא במערך ממנו העתקנו. • לאחר שנגיע לקצה אחד המערכים, נעתיק את האיברים הנותרים מהשני. • מספר השוואות נדרש: לכל היותר m+n-1 (אחרי כל השוואה מועבר אבר למקומו במערך החדש, והאבר האחרון מועבר ללא צרך בהשוואה). מספר ההשואות הוא לינארי בארך הקלט. מבוא למדעי המחשב במטלאב

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 89 89 89 89 89 89 89 89 89 89 89 89 89 89 89 89 89 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 8 8 8 8 8 8 8 8 8 8 8 8 8 34 34 34 34 34 34 34 34 34 34 34 34 34 144 144 144 144 144 144 144 144 144 144 144 144 144 0 0 0 0 2 2 2 2 8 8 8 8 34 34 34 34 144 144 144 144 610 610 610 610 2584 2584 2584 2584 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 5 5 5 5 5 5 8 8 8 8 8 13 13 13 13 21 21 21 34 34 55 55 89 0 0 0 0 1 1 1 1 1 1 1 1 2 2 2 2 3 3 3 3 5 5 5 5 8 8 8 8 13 13 13 13 21 21 21 21 34 34 34 34 55 55 55 55 89 89 89 89 144 144 144 610 610 2584 הדגמת אלגוריתם המיזוג 610 2584 מבוא למדעי המחשב במטלאב

מיזוג • function c = merge(a,b) • % given non decreasing sorted arrays a,b • % return in c the sorted merge of a and b • n_a = length(a); n_b = length(b); • n_c = n_a + n_b; c = zeros(1,n_c); • i_a = 1; i_b = 1; • fori_c = 1 : n_c; • ifi_b > n_b • c(i_c) = a(i_a); • i_a = i_a +1; • elseifi_a > n_a • c(i_c) = b(i_b); • i_b = i_b +1; • elseif a(i_a) < b(i_b) • c(i_c) = a(i_a); • i_a = i_a +1; • else% a(i_a) >= b(i_b) • c(i_c) = b(i_b); • i_b = i_b +1; • end • end

מיון מיזוג רקורסיבי • מיון מיזוג רקורסיבי (Recursive Merge Sort) הוא שיטה למיון סדרה בה מחלקים את הסדרה לשני חצאים שלאחר מיונם (באופן רקורסיבי)ממזגים אותם. • השיטה: • אם אורך הסדרה קטן מ-2– הסדרה ממוינת – חזור. • חלק את הסדרה לשני חצאים, • מיין כל אחד משני החצאים (ע"י קריאה רקורסיבית), • מזג את שני החצאים מבוא למדעי המחשב במטלאב

מיון מיזוג רקורסיבי • function b = msort(a) • if length(a) = 1 • b = a; • return • end • m = ceil(length(a)/2); • b = merge(msort(a(1:m)), msort(a(m+1:end)));

הדגמה (ויקיפדיה) פרישת רקורסיה קיפול רקורסיה

הוכחת נכונות מיון מיזוג רקורסיבי אינדוקציה על גדל המערך. בסיס: מערך בגודל 1 מוחזר ממוין. שלב מעבר: נניח מערכים בגודל קטן מ n ממוינים נכון, ויהי נתון מערך a בגודלn>1 . במקרה זה מתקיים: m = floor(n/2) < n. לכן, מהנחת האינדוקציה, בעת ביצוע שורה 7, הקריאות הרקורסיביות: msort(a(1:m)), msort(a(m+1:end)) מחזירות את תתי המערכים a(1:m) ו a(m+1:n) ממוינים. מכאן, ומנכונות אלגוריתם המיזוג, לאחר ביצוע שורה 7 מערך a ממוין. בשקפים הבאים נראה דרך להעריך את מספר ההשוואות הנדרש מבוא למדעי המחשב במטלאב

T(n) = O(1) ifn< 2; 2T(n/2) + O(n) ifn > 1. Time Complexity of Merge-Sort (presentation by Silvio Micali, MIT) MERGE-SORTa(1:n) T(n) 1. O(1) 2. 2T(n/2) 3. O(n) • If n< 2, done • 2. Recursively sort • a(1 : n/2)and a(n/2 + 1 : n) • 3. “Merge” the two sorted lists

Recurrence solving Solve T(n) = 2T(n/2) + cn, where c > 0 is constant.

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. T(n)

cn T(n/2) T(n/2) Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant.

cn cn/2 cn/2 T(n/4) T(n/4) T(n/4) T(n/4) Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant.

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn/2 cn/2 cn/4 cn/4 cn/4 cn/4 … … Q(1)

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn cn/2 cn/2 cn/4 cn/4 cn/4 cn/4 … … Q(1)

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn cn/2 cn cn/2 cn/4 cn/4 cn/4 cn/4 … … Q(1)

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn cn/2 cn cn/2 cn/4 cn/4 cn cn/4 cn/4 … … … Q(1)

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn cn/2 cn cn/2 h = lgn cn/4 cn/4 cn cn/4 cn/4 … … … Q(1) Q(n) #leaves = n

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn cn/2 cn cn/2 h = lg n cn/4 cn/4 cn cn/4 cn/4 … … … Q(1) Q(n) Total = ? #leaves = n

Recursion tree Solve T(n) = 2T(n/2) + cn, where c > 0 is constant. cn cn cn/2 cn cn/2 h = lgn cn/4 cn/4 cn cn/4 cn/4 … … Q(1) O(n) Total=O(nlgn) #leaves = n

מספר השוואות במיון מיזוג: הוכחה באינדוקציה טענה: במיון מיזוג רקורסיבי מבוצעות פחות מ nlog2(n) השוואות בין אברי הסדרה. נוכיח את הטענה עבור n=2k יהי T(n) מספר ההשוואות המקסימלי המבוצע על סדרת קלט באורך n=2k. צ.ל. T(n)< nlog2(n) . עבור n=1=20 מתבצעות 0 השוואות. נניח שהטענה נכונה עבור n, ונוכיח נכונות עבור 2n. T(2n)≤2T(n)+2n= 2nlog2(n)+2n= 2n[log2(n)+1]= (2n)log2(2n) פעמיים מיון של סדרות בגודל n מיזוג מבוא למדעי המחשב במטלאב

סיכום – מיון • ידועים כיום מספר רב של אלגוריתמים למיון. ניתן לחלקם לשתי משפחות: • האלגוריתמים ה"פשוטים" (מקס, בועות): • סיבוכיות הזמן הינה ריבועית: O(n2) • סיבוכיות המקום* הינה קבועה. • אלגוריתמים אופטימליים מבחינת מספר השוואות (מיון מיזוג). • סיבוכיות הזמן הינה nlog(n) • סיבוכיות המקום של mergesortהינה לינארית.קיימים אלגוריתמים בעלי סיבוכיות זמן דומה וסיבוכיות מקום קבועה. מבוא למדעי המחשב במטלאב

מבוא למחשב בשפת Matlab