1 / 47

קורס מחשב לרפואנים 274121

קורס מחשב לרפואנים 274121. הרצאה 10: חיפושים ומיונים יעילים. נכתב על-ידי ראובן בר-יהודה. משאבי זמן וזיכרון של תוכניות מחשב: תזכורת. אלו מתתי התוכניות הבאות צורכת יותר זמן? הנחה: כל פעולה "בסיסית" עולה 1 יחידות זמן. עבור n=0 5 פעולות כל איטרציה מוסיפה 7 פעולות Time(n) = 5 + 7*n

ingrid
Download Presentation

קורס מחשב לרפואנים 274121

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. קורס מחשב לרפואנים274121 הרצאה 10: חיפושים ומיונים יעילים נכתב על-ידי ראובן בר-יהודה.

  2. משאבי זמן וזיכרון של תוכניות מחשב: תזכורת • אלו מתתי התוכניות הבאות צורכת יותר זמן? הנחה: כל פעולה "בסיסית" עולה 1 יחידות זמן. עבור n=0 5 פעולות כל איטרציה מוסיפה 7 פעולות Time(n) = 5 + 7*n עבור n=0 4 פעולות כל איטרציה מוסיפה 5 פעולות סך מספר האיטרציות הוא n2 Time(n) = 4 + 5*n2 • y =0; • i= 0 + 0 + 0; • while i< n • i=i+1; • y = y +i*i*i; • end • i=n*n; • y= 0; • while i>0 • i = i- 1; • y = y +i; • end

  3. משאבי זמן וזיכרון של תוכניות מחשב: תזכורת אמנם עבור n-ים קטנים הפרבולה מתחת לישר אבל עבור n-ים גדולים הפרבולה גבוהה יותר. מה שמעניין אותנו הם סדרי הגודל: התוכנית הראשונה צורכת זמן בסדר גודל לינארי התוכנית השנייה צורכת זמן בסדר גודל ריבועי ריבועי לינארי

  4. משאבי זמן וזיכרון של תוכניות מחשב (סיבוכיות): תזכורת דוגמאות לסדרי גודל קבוע: (מסומן ב-(O(1): 1, 10, 123.235, 10001000 לינארי (מסומן ב-(O(n):5 + 5*n, 5n+1999, 0.001n+100000, n+n0.7 ריבועי (מסומן ב-(O(n2):5 + 5*n2, 5n+1999+n2, 0.001n2+100000, 1+2+…+n פולינומי: (מסומן ב poly(n) או (nO(1): 5 + 5*n11, 5n+1999+n12, 0.001n22+100000, לוגריתמי (מסומן ב-((O(log(n):5 + 5*log(n), log(1+2+3+…+n) , log22(n) ובלתי נסבל: אקספוננציאלי: , 1.13n+2 ,2n

  5. סיבוכיות: הבהרות מטרות: • להיות מודעים למגבלות משאבי המחשב, ולמשל, להמנע מתוכניות שצורכות זמן בלתי נסבל (כמו שנראה מיד, אקספוננציאלי) • לעזור בפיתוח תוכניות יעילות כמו שנעשה בהמשך, למשל, בעיות של חיפוש בזמן O(log(n)), מיזוג בזמן לינארי ומיון בזמן O(nlog(n)) שנלמד בשיעור זה (ובעיות נוספות שנלמד בעתיד). מבחן סופי: • לא יהיו שאלות בהם אתם נדרשים לנתח או להוכיח סיבוכיות (כפי שהיה בסמסטרים קודמים) • אבל כן נבקש משימות תחת מגבלות סיבוכיות.

  6. פתרונות רקורסיביים בזבזניים • פתרון רקורסיבי עלול להיות מאד לא יעיל מבחינת סיבוכיות זמן (או מקום). • נדגים זאת על ידי פונקציה רקורסיבית פשוטה לחישוב האבר ה n-י בסדרת פיבונאצ'י. • נעיר שהתכנית הכי יעילה לחישוב האבר ה n-י היא על ידי שימוש בנוסחה הסגורה

  7. rfib: תכנית רקורסיבית לסדרת פיבונאצ'י • להלן פונקציה רקורסיבית לחישוב האבר ה n-י בסדרת פיבונאצ'י על פי ההגדרה. • פונקציה זו מאד לא יעילה: (אקספוננציאלית) function f=rfib(n) if n<=2 f=1; else f=rfib(n-1)+rfib(n-2); end

  8. function f=F(n) if n<=2 f=1; else f=F(n-1)+F(n-2); end F(6) n=6 f = + F(5) F(4) n=5 f = + 3 F(4) F(3) n=4 f = + 2 1 F(3) F(2) n=3 f = + n=2 f = 1 2 F(2) F(1) 1 1 n=1 f = 1 n=2 f = 1

  9. הוכחת אקספוננציאליות של rfib באינדוקציה יהי Timenמספר הפעולות הנדרשות לביצועrfib(n) . נוכיח φn<Timen באינדוקציה. בסיס:Time1 = 3 > φ1, Time2 = 3 > φ2 . צעד: הזמן לחשב עבור n כרוך בין היתר בקריאה לפונקציה עבור n-2 ועבור n-1 ולכן: function f=rfib(n) if n <= 2 f=1; else f=rfib(n-1)+rfib(n-2); end • Timen> Timen-1 + Timen-2 • > φn-1 + φn-2 % מהנחת האינדוקציה • > φn-2 (φ+ 1) • = φn-2 φ2 %x2 – x – 1 = 0 שורש של φ • =φn

  10. דרך נוספת: Timen> מספר העלים = rfib(n) f(7) function f=rfib(n) if n<=2 f=1; else f=rfib(n-1)+rfib(n-2); end f(6) f(5) f(4) f(4) f(3) f(3) f(2) f(3) f(2) f(2) f(1) f(2) f(1) f(2) f(1)

  11. מימוש אינדוקטיבי (תכנון דינאמי) של מספרי פיבונאצ'י מספר הפעולות הוא לינארי. חישוב זה שומר את כל n האברים הראשונים בסדרת פיבונאצ'יבוקטורf. האם ניתן לחשב את מספר פיבונאצ'י ה n-י בפחות זכרון? functionfib = myfib0(n) % Fibonacci number computation f = zeros(1,n); %memory allocation f(1)=1;f(2)=1; for k=3:n f(k)=f(k-1)+f(k-2); end fib=f(n);

  12. חישוב לא רקורסיבי של מספרי פיבונאצ'י שאינו שומר את כל הסדרה function f2=myfib1(n) % Fibonacci number computation if (n<3) f2=1; return, end f1=1;f2=1; for k=3:n %set [f1, f2] to [f(k-1), f(k)]. [f1,f2]=deal(f2,f1+f2); end מספר הפעולות הדרוש בחישוב זה הוא לינארי. גדל הזכרון הדרוש בMatlab הוא עדיין לינארי, עקב השימוש ב for. האם ניתן בפחות זכרון?

  13. חישוב יעיל של מספר פיבונאצ'י בסבוכיות זיכרון קטנה מספר פעולות ההצבה הדרוש בחישוב זה הוא לינארי כמו קודם, אבל גדל הזכרון הדרוש הוא רק שלושה משתנים סקאלריים: k, f1, f2. functionf2 = myfib2(n) %compute Fibonacci number within constant space if (n < 3) f1 = 1; return end k = 3; f1 = 1; f2 = 1; whilek <= n [f1, f2] = deal(f2,f1+f2); k = k + 1; end

  14. חיפוש במערכים ממוינים

  15. חיפוש בינארי • function m = bin_search (x, a) • % a is a non decreasing sorted array • % find x in a and return in m its index. • % if x is not there, m = -1 • b = 1; t = length(a); • while b <= t • m = floor((b+t)/2); • if a(m) == x • return • elseif a(m) > x • t = m-1; • else • b = m+1; • end • end • m = -1;

  16. b t חיפוש בינארי: נכונות שמורות בכל איטרציה x לא נמצא ב a(1 : b-1) x לא נמצא ב a(t+1: end) הוכחה: באינדוקציה על מספר האיטרציות: בסיס: 0 איטרציות- נכונות באופן ריק. צעד: אם a(m) > x אז כל האיברים ב a(m:end) גדולים ממש מ-x ולכן הוא לא שם, אם a(m) < x אז כל האיברים ב a(1:m) קטנים ממש מ-x ולכן הוא לא שם. בסיום: אם x לא נמצא (שורה 5) אז נגיע לשורה 13 בה מתקיים b>t ומכאן נובע שהאיחוד של a(t+1: end) ו a(1 : b-1) מכיל את כל איברי a ולכן, לפי השמורות,x לא נמצא ב-a • function m = bin_search (x, a) • b = 1; t = length(a); • while b <= t • m = floor((b+t)/2); • if a(m) == x • return • elseif a(m) > x • t = m-1; • else • b = m+1; • end • end • m = -1;

  17. חיפוש בינארי: סיבוכיות זמן O(log(n)) • function m = bin_search (x, a) • b = 1; t = length(a); • while b <= t • m = floor((b+t)/2); • if a(m) == x • return • elseif a(m) > x • t = m-1; • else • b = m+1; • end • end • m = -1; בכל איטרציה האינטרוואל b:t נחצה ב-2. אם אורכו בהתחלה היה n אז לאחר איטרציה אחת הוא יהיה בערך n/2 לאחר עוד איטרציה הוא יהיה בערך n/4 לאחר עוד איטרציה הוא יהיה בערך n/8 ולכן לאחר k איטרציות הוא יקטן ל n/2k ש: עבור איזה k הביטוי הנ"ל יהיה קטן מדי? ת: נפתור את אי השוויון: 1 > n/2k או: 2k > n וזה יקרה כאשר k = log2(n) מכאן מספר האיטרציות (ולכן סיבוכיות הזמן) הוא (O(log(n)

  18. חיפוש בינארי: מימוש רקורסיבי • functioni = r_bin_search (x, a, b, t) • % a is a non decreasing sorted array • % find x in a(b:t) and return in i its index. • % if x is not there, i = -1 • m = floor((b+t)/2); • if b > t • i = -1; • elseif a(m) == x • i = m; • elseif a(m) > x • i = r_bin_search(x, a, b, m-1); • else • i = r_bin_search(x, a, m+1, t); • end

  19. Meet Merge Sort (SilvioMichli MIT) MERGE-SORTa(1:n) • If n== 1, done (nothing to sort). divide and conquer Otherwise, recursively sort a(1 : n/2)and a(n/2 + 1 : n) “Merge” the two sorted sub-arrays. Key function:MERGE

  20. הדגמה (ויקי)

  21. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 … output array

  22. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 … 1 output array

  23. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 … 1 output array

  24. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 … 1 2 output array

  25. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 … 1 2 output array

  26. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 … 1 2 7 output array

  27. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 20 13 12 11 9 … 1 2 7 output array

  28. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 20 13 12 11 9 … 1 2 7 9 output array

  29. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 20 13 12 11 9 20 13 12 11 … 1 2 7 9 output array

  30. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 20 13 12 11 9 20 13 12 11 … 1 2 7 9 11 output array

  31. Merging two sorted arrays (SilvioMicali MIT) 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 20 13 12 11 9 20 13 12 11 20 13 12 … 1 2 7 9 11 output array

  32. 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 20 13 12 11 9 20 13 12 11 20 13 12 1 2 7 9 11 12 Merging two sorted arrays (SilvioMicali MIT) … output array

  33. 20 13 7 2 12 11 9 1 20 13 7 2 12 11 9 20 13 7 12 11 9 20 13 12 11 9 20 13 12 11 20 13 12 1 2 7 9 11 12 Merging two sorted arrays (SilvioMicali MIT) … output array Time = Q(n) to merge a total of nelements (linear time).

  34. T(n) = O(1) ifn== 1; 2T(n/2) + O(n) ifn > 1. Analyzing merge sort (SilvioMicali MIT) MERGE-SORTa(1:n) T(n) O(1) 2T(n/2) O(n) • If n== 1, done • 2. Recursively sort • a(1 : n/2)and a(n/2 + 1 : n) • 3. “Merge” the two sorted lists

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

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

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

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

  39. Recursion tree (SilvioMicali MIT) 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)

  40. Recursion tree (SilvioMicali MIT) 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)

  41. Recursion tree (SilvioMicali MIT) 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)

  42. Recursion tree (SilvioMicali MIT) 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)

  43. Recursion tree (SilvioMicali MIT) 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)

  44. Recursion tree (SilvioMicali MIT) 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

  45. Recursion tree (SilvioMicali MIT) 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

  46. Recursion tree (SilvioMicali MIT) 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

  47. מיזוג מערכים ממוינים: בשעור הבא...

More Related