פונקצית זמן ריצה
Download
Report
Transcript פונקצית זמן ריצה
ניתן להתייחס ליעילותם של אלגוריתמים משני היבטים:
• יעילות מבחינת מקום בזיכרון הנדרש לביצוע התכנית.
•יעילות מבחינת זמן הביצוע של האלגוריתם.
שני מדדים אלה
נקראים
מדדי סיבוכיות
אנו נתייחס בפרק זה ליעילות מבחינת זמן ביצוע
כיצד נמדוד יעילות של אלגוריתם?
• יעילות אלגוריתם נמדדת לפי משך זמן הביצוע של האלגוריתם > --זהו דבר שתלוי
במספר הפעולות שהוא מבצע ובאורך הקלט.
מהי פונקצית זמן ריצה של אלגוריתם?
•פונקצית זמן ריצה היא ביטוי אלגברי המתאר את מספר יחידות הזמן שאורך
האלגוריתם.
•מאחר וכל פעולה נמשכת יחידת זמן אחת (למעט יוצא דופן) ,ניתן לחשב את פונקצית
זמן הריצה על – ידי מנייה של הפקודות ,בהתאם לסביבת העבודה בה אנו עובדים.
כללים לחישוב פונקצית זמן ריצה בשפת פסקל:
• כל פעולה בסיסית נספרת כיחידת זמן אחת למעט הפעולות היוצאות
דופן המוזכרות לעיל.
•הוראת תנאי
כאשר יש תנאי מורכב נספור כל ביטוי בוליאני כפעולה .למשל התנאיהבא:
If(a>b) and(a>c)and(b>c) thenנספור כשלוש פעולות כי הוא מכיל
שלושה ביטויים בוליאניים.
גוף התנאי נספר לפי המספר הגדול של הפעולות שמתבצעות כאשר התנאימתקיים או אינו מתקיים
• ביצוע חוזר -לולאה
כאשר יש לולאה ,יש לספור את מספר הפעולות בבלוק הלולאה ,ולהכפיל אותןבמספר הפעמים המקסימלי שהלולאה יכולה להתבצע.
לולאת forאינה נספרת כפקודה.לולאת whileנספרת לפי מספר הביטויים הבוליאניים שבה ,למשל ההוראה while(i<=n) and (not found) doנספרת כשתי פעולות כי היא מכילה שני
ביטויים בוליאניים.
;)Readln(num
פונקצית זמן ריצה 3 :
;S:=num*num
הסבר :אלגוריתם זה מכיל 3
הוראות פשוטות
;)Writeln(s
;)Readln(n1,n2
If (n1>n2) then
Begin
;d:=n1-n2
;)writeln(d
End
Else
;)writeln(n2
פונקצית זמן ריצה 4 :
הסבר :באלגוריתם זה יש הוראת
קלט ולאחריה הוראת תנאי היכול
להתקיים או שלא להתקיים .בדיקת
הביטוי הבוליאני נמנית כפעולה
אחת .לאחר מכן עבור ביצוע התנאי
יש לבחור את המקרה הגרוע יותר,
כלומר ,באיזה מקרה יתבצעו יותר
הוראות ,כאשר התנאי מתקיים או
כאשר התנאי אינו מתקיים .במקרה
זה ,יש יותר הוראות כאשר התנאי
מתקיים ,ולכן עבור גוף התנאי
יחושבו 2פעולות .סה"כ4= 1+1+2 :
;)Readln(grd1, grd2
If (grd1<55) or (grd2<55) then
if (grd1<55) and (grd2<55) then
)`writeln(`very bad
Else
;)`writeln(`u have to do test
Else
begin
;avg :=(grd1+grd2)/2
;)writeln(avg
;end
פונקצית זמן ריצה 6 :
הסבר :התנאי החיצוני אורך 2
יחידות כי יש בו 2ביטויים בוליאניים.
אם התנאי מתקיים יש לבצע 3
הוראות של התנאי הפנימי ,ואם אינו
מתקיים – 2הוראות .נבחר במקרה
בו התנאי מתקיים ,כי זה המקרה
הגרוע ביותר.
מכאן שהתנאי כולו אורך 5יחידות
זמן .נוסיף את ההוראה הראשונה
ונקבל סה"כ 6יחידות זמן.
;Sum:=0
For I:=1 to n do
Begin
;)readln(num
;sum:=sum+num
;End
פונקצית זמן ריצה 2n+2 :
הסבר :הלולאה מתבצעת nפעמים.
בגוף הלולאה 2הוראות – סה"כ .2n
שים לב :פעולת forאינה
נמנית כפעולה .בנוסף יש
שתי הוראות מחוץ ללולאה ,
סה"כ 2n+2 :
;)Writeln(sum
;i:=1
;Found:=false
While (i<=n)and(not found) do
Begin
;)readln(num
if num=-1 then
found:=true
else
;i:=i+1
;End
;)Writeln(i
פונקצית זמן ריצה 5n+3:
הסבר :יש 3הוראות מחוץ ללולאה.
הוראת ה whileנמנית כ 2-פעולות
מאחר ויש בה 2ביטויים בוליאניים.
בגוף הלולאה יש 3פעולות ולכן יש 5
פעולות שחוזרות על עצמן בכל ביצוע
של הלולאה .הלולאה מתבצעת לכל
היותר nפעמים = .5n+3
for i:=1 to n do
readln(a[i], b[i]);
n מתבצע
פעמים
For i:=1 to n do
Begin
n²+4n: פונקצית זמן ריצה
sum:=0;
for j:=1 to n do
sum:= sum + a[i]*b[j];
c[i] :=sum;
לולאה
פנימית
מתבצע
n
פעמים
לולאה
: חיצונית
פעולות
המתבצעות
n+2
End;
For i:=1 to m do
writeln(c[i]);
n מתבצע
פעמים
n+n(n+2)+n = n+ n² + 2n +n = n²+4n
לולאה
: חיצונית
מתבצעת
n(n+2)
סיבוכיות זמן הריצה של אלגוריתם (הנקראת גם סדר גודל זמן הריצה) נקבעת לפי הגורם
המשמעותי ביותר בפונקצית זמן הריצה ,תוך התעלמות מהקבוע הכלול באיבר זה מאחר
ובערכים גדולים של אורך הקלט הוא הופך להיות זניח.
סיבוכיות זמן הריצה מסומנת ב – .O
כאשר משך זמן הריצה של האלגוריתם קבוע (אינו תלוי באורך הקלט) ,הסיבוכיות היא )O(1
;)Readln(num
;S:=num*num
;)Writeln(s
פונקצית זמן ריצה 3 :
סיבוכיות זמן ריצה )O(1
Readln(n1,n2);
If (n1>n2) then
Begin
4 : פונקצית זמן ריצה
O(1) : סיבוכיות זמן ריצה
d:=n1-n2;
writeln(d);
End
Readln(grd1, grd2);
If (grd1<55) or (grd2<55) then
if (grd1<55) and (grd2<55) then
writeln(`very bad`)
6 : פונקצית זמן ריצה
: סיבוכיות זמן ריצה
O(1)
Else
writeln(`u have to do test`);
Else
begin
avg :=(grd1+grd2)/2;
writeln(avg);
end;
Else
writeln(n2);
Sum:=0;
For I:=1 to n do
2n+2 : פונקצית זמן ריצה
Begin
readln(num);
O(n) : סיבוכיות זמן ריצה
sum:=sum+num;
End;
Writeln(sum);
i:=1;
Found:=false;
While (i<=n)and(not found) do
5n+3: פונקצית זמן ריצה
Begin
readln(num);
O(n) : סיבוכיות זמן ריצה
if num=-1 then
found:=true
else
i:=i+1;
End;
Writeln(i);
for i:=1 to n do
readln(a[i], b[i]);
For i:=1 to n do
Begin
n²+4n: פונקצית זמן ריצה
sum:=0;
for j:=1 to n do
O(n²) : סיבוכיות זמן ריצה
sum:= sum + a[i]*b[j];
c[i] :=sum;
End;
For i:=1 to m do
writeln(c[i]);
צעד בסיסי הוא אוסף ההוראות החוזרות על עצמן הכי הרבה פעמים
במהלך ביצוע האלגוריתם.
לכל אלגוריתם יש לפחות צעד בסיסי אחד.
משך זמן הביצוע של הצעד הבסיסי הוא קבוע ,כלומר אינו תלוי באורך
הקלט.
מספר הפעמים שהצעד הבסיסי מתבצע תלוי באורך הקלט אך לא
הצעד הבסיסי עצמו.
Sum:=0;
For I:=1 to n do
Begin
1
readln(num);
sum:=sum+num;
End;
Writeln(sum);
i:=1;
Found:=false;
While (i<=n)and(not found) do
Begin
readln(num);
2
if num=-1 then
found:=true
else
i:=i+1;
End;
Writeln(i);
for i:=1 to n do
;)]readln(a[i], b[i
For i:=1 to n do
Begin
;sum:=0
for j:=1 to n do
;]sum:= sum + a[i]*b[j
3
;c[i] :=sum
;End
For i:=1 to m do
;)]writeln(c[i
לכל אלגוריתם אורך הקלט המשפיע על משך זמן הביצוע של האלגוריתם.
ברור שסריקת מערך בן 10איברים תהיה מהירה יותר מסריקת מערך בן 10,000איברים.
בכל אלגוריתם ניתן להגדיר אורך קלט כמספר הפעמים שמתבצע הצעד הבסיסי ,אך קיימים
אלגוריתמים בהם ניתן להגדיר אורכי קלט נוספים.