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

:10הרצאה חיפושים ומיונים יעילים

נכתב על-ידי ראובן בר-יהודה.

משאבי זמן וזיכרון של תוכניות מחשב: תזכורת

2

אלו מתתי התוכניות הבאות צורכת יותר זמן?•

יחידות זמן.1הנחה: כל פעולה "בסיסית" עולה

פעולותn=0 5עבור

פעולות7כל איטרציה מוסיפה

Time(n) = 5 + 7*n

פעולותn=0 4עבור

פעולות5כל איטרציה מוסיפה

n2סך מספר האיטרציות הוא

Time(n) = 4 + 5*n2

1. y = 0;

2. i = 0 + 0 + 0;

3. while i < n

4. i = i + 1;

5. y = y + i*i*i;

6. end

1. i = n*n;

2. y = 0;

3. while i >0

4. i = i - 1;

5. y = y + i;

6. end

משאבי זמן וזיכרון של תוכניות מחשב: תזכורת

3

0 1 2 3 4 5 6 7 8 9 100

50

100

150

200

250

300

350

n

time

-ים קטנים הפרבולה מתחת לישר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ריבועי (מסומן ב-(, nO(1): 5 + 5*n11, 5n+1999+n12, 0.001n22+100000 או (poly(n)פולינומי: (מסומן ב

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נעיר שהתכנית הכי יעילה לחישוב האבר ה •הסגורה

נוסחה רקורסיבית נוסחה סגורה

סדרת פיבונאצ'י1, 1, 2, 3, 5, 8, 13,…

a2 = a1 = 1

an = an-1 + an-2

an = (φn - (1 - φ)n) / 5φ = (1+5) / 2 ~= 1.6180כאשר

x2 – x – 1 = 0שהוא שורש של

7

rfib תכנית רקורסיבית לסדרת פיבונאצ'י :

-י בסדרת nלהלן פונקציה רקורסיבית לחישוב האבר ה •פיבונאצ'י על פי ההגדרה.

פונקציה זו מאד לא יעילה: (אקספוננציאלית)•

function f=rfib(n) if n<=2 f=1; else f=rfib(n-1)+rfib(n-2); end

n=6

f = +

8

function f=F(n) if n<=2 f=1; else f=F(n-1)+F(n-2); end

F(6)

F(5) F(4) n=5

f = +F(4) F(3) n=4

f = +F(3) F(2)

n=3

f = +F(2) F(1)

n=2

f = 1

1n=1

f = 1

12

2 n=2

f = 1

1

3

9

rfibהוכחת אקספוננציאליות של באינדוקציה

מספר הפעולות הנדרשות לביצוע Timenיהי

rfib(n) נוכיח . φn<Timen.באינדוקציה

Time1 = 3 > φ1, Time2 = 3 > φ2 בסיס:

.

כרוך בין היתר n הזמן לחשב עבור צעד: n-1 ועבור n-2בקריאה לפונקציה עבור

ולכן:

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

rfib(n)< מספר העלים = Timen דרך נוספת:

f(2) f(1)

f(3)

f(2) f(1)

f(3) f(2)

f(4)

f(2) f(1)

f(3) f(2)

f(4)f(5)

f(6)

function f=rfib(n) if n<=2 f=1; else f=rfib(n-1)+rfib(n-2); end

f(7)

11

מימוש אינדוקטיבי )תכנון דינאמי( של מספרי פיבונאצ'י

מספר הפעולות הוא לינארי.

.f האברים הראשונים בסדרת פיבונאצ'י בוקטור n חישוב זה שומר את כל

function fib = myfib(n)% Fibonacci number computationf = zeros(1,n); %memory allocationf(1)=1;f(2)=1; for k=3:n f(k)=f(k-1)+f(k-2);endfib=f(n);

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

12

חיפוש בינארי

13

1.function m = bin_search (x, a) 2. % a is a non decreasing sorted array3. % find x in a and return in m its index.4. % if x is not there, m = -15. b = 1; t = length(a);6. while b <= t7. m = floor((b+t)/2);8. if a(m) == x9. return10. elseif a(m) > x11. t = m-1;12. else13. b = m+1;14. end15. end16. m = -1;

חיפוש בינארי: נכונות

14

1.function m = bin_search (x, a) 2. b = 1; t = length(a);3. while b <= t4. m = floor((b+t)/2);5. if a(m) == x6. return7. elseif a(m) > x8. t = m-1;9. else10. b = m+1;11. end12. end13. m = -1;

בכל איטרציהשמורות 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קטנים ממש מ-

)5 לא נמצא (שורה x: אם בסיוםb>t בה מתקיים 13אז נגיע לשורה

ומכאן נובע שהאיחוד שלa(t+1: end) ו a(1 : b-1)

a לא נמצא ב-x ולכן, לפי השמורות,aמכיל את כל איברי

b t

))O)log)nחיפוש בינארי: סיבוכיות זמן

15

1. function m = bin_search (x, a) 2. b = 1; t = length(a);3. while b <= t4. m = floor((b+t)/2);5. if a(m) == x6. return7. elseif a(m) > x8. t = m-1;9. else10. b = m+1;11. end12. end13. m = -1;

.2 נחצה ב-b:tבכל איטרציה האינטרוואל nאם אורכו בהתחלה היה

n/2אז לאחר איטרציה אחת הוא יהיה בערך n/4לאחר עוד איטרציה הוא יהיה בערך n/8לאחר עוד איטרציה הוא יהיה בערך

n/2k איטרציות הוא יקטן ל kולכן לאחר

הביטוי הנ"ל יהיה קטן מדי?kש: עבור איזה n/2k > 1ת: נפתור את אי השוויון:

2k > nאו: k = log2(n)וזה יקרה כאשר

מכאן מספר האיטרציות O(log (n)(ולכן סיבוכיות הזמן) הוא (

חיפוש בינארי: מימוש רקורסיבי

1. function i = r_bin_search (x, a, b, t) 2. % a is a non decreasing sorted array3. % find x in a(b:t) and return in i its index.4. % if x is not there, i = -15. m = floor((b+t)/2);6. if b > t7. i = -1;8. elseif a(m) == x9. i = m;10. elseif a(m) > x11. i = r_bin_search(x, a, b, m-1);12. else 13. i = r_bin_search(x, a, m+1, t);14. end

16

Meet Merge Sort )Silvio Michli MIT(

MERGE-SORT a(1:n)

1. If n == 1, done (nothing to sort).

Key function: MERGE

divide and conquer

2. Otherwise, recursively sort a(1 : n/2) and a(n/2 + 1 : n)

3. “Merge” the two sorted sub-arrays.

הדגמה )ויקי(

18

מיון מיזוג – נכונות+סיבוכיות+מימוש מיזוג

בשבוע הבא...

1. function b = msort(a)2. if length(a)<23. b = a;4. return5. end6. m = ceil(length(a)/2);7. b = merge(msort(a(1:m)),

msort(a(m+1:end)));

19