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

קורס מחשב לרפואנים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 חישוב זה שומר את כל

-י בפחות זכרון?nהאם ניתן לחשב את מספר פיבונאצ'י ה

function fib = myfib0(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

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

מספר הפעולות הדרוש בחישוב זה הוא לינארי.

.for הוא עדיין לינארי, עקב השימוש ב Matlab גדל הזכרון הדרוש ב

האם ניתן בפחות זכרון?

function f2=myfib1(n)% Fibonacci number computationif (n<3) f2=1; return,endf1=1;f2=1; for k=3:n %set [f1, f2] to [f(k-1), f(k)]. [f1,f2]=deal(f2,f1+f2);end

13

חישוב יעיל של מספר פיבונאצ'י בסבוכיות זיכרון קטנה

מספר פעולות ההצבה הדרוש בחישוב זה הוא לינארי כמו קודם,

.k, f1, f2 אבל גדל הזכרון הדרוש הוא רק שלושה משתנים סקאלריים:

function f2 = myfib2(n)%compute Fibonacci number within constant space if (n < 3) f1 = 1; returnendk = 3; f1 = 1; f2 = 1;while k <= n [f1, f2] = deal(f2,f1+f2); k = k + 1;end

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

14

חיפוש בינארי

15

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;

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

16

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חיפוש בינארי: סיבוכיות זמן

17

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

18

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.

הדגמה )ויקי(

20

Merging two sorted arrays )Silvio Micali MIT(

20

13

7

2

12

11

9

1

output array

…

20

13

7

2

12

11

9

1

1output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11

20

13

12

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11

20

13

12

12output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11

20

13

12

12

Time = Q(n) to merge a total of n elements (linear time).

output array

…


Analyzing merge sort )Silvio Micali MIT(

MERGE-SORT a(1:n)

1. If n == 1, done2. Recursively sort

a(1 : n/2) and a(n/2 + 1 : n)3. “Merge” the two sorted lists

T(n)

O(1)

2T(n/2)

O(n)

T(n) =O(1) if n == 1;

2T(n/2) + O(n) if n > 1.

Recurrence solving )Silvio Micali MIT(

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

Recursion tree )Silvio Micali MIT(


T(n)



T(n/2) T(n/2)

cn



cn

T(n/4) T(n/4) T(n/4) T(n/4)

cn/2 cn/2



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

cn

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

cn

cn

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

cn

cn

cn

…

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

h = lg n

cn

cn

cn

Q(n)

…

#leaves = n

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

h = lg n

cn

cn

cn

Q(n)

Total = ?

…

#leaves = n

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

h = lg n

cn

cn

cn

#leaves = n

O(n)

Total = O(n lg n)

…

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

47

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

Documents

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