- 0 -

נתונים מבני

לקט שאלות ממבחנים

- 1 -

סדרי גודל ניתוח

:1שאלה ות ישירות על ידי שימוש בהגדרות הבאותהוכיחו או הפריכו את הטענ

3. א 2 3( )n n n− = Ω )log. ב ) ( )n n n n⋅ − = Ω

). ג )log(log n)2 O n=

. ד2

2

log (n 5)

(n 5) O(n)2 +

−=

). ה ) ( )610 10n n= Θ

). ו )log( ) log( )n

n n n= Ω ⋅

)log()3log)((. ז 2 nnn Θ=⋅+. ). ח )2

2 2n nn= Θ

)log .ט !) ( log( ))n n n= Θ ⋅

:2שאלה )1עבור הפונקציה ) בסדר גודל(מצאו חסם הדוק ) n

nf n .י הגדרה את החסם שמצאתם"הוכיחו עפ. =+

:3שאלה :הוכיחו או הפריכו

אז f1=O(g1) ,f2=O(g2) : פונקציות חיוביות עולות לאינסוף המקיימות f1, f2, g1, g2אם . אg1*g2 = Ω(f1*f2).

אז f1=O(g1) ,f2=O(g2) : פונקציות חיוביות עולות לאינסוף המקיימות f1, f2, g1, g2אם . ב

f1f2 = O(g1

g2) . .n! = θ(n*2n). ג

∑אם . ד=

=n

i

inf0

) אז )(2 )nnf 2)( Ο=

)אם . ה )nnnf Ο=⋅ )log()( אז ( )nnf Ο=)(. 2121אם . ו ,,, ggffפונקציות חיוביות עולות לאינסוף המקיימות : ( ) ( )2211 , gfgf Θ=Θ= אז

⎟⎟⎠

⎞⎜⎜⎝

⎛Ο=

2

1

2

1

gg

ff

- 2 -

:4שאלה ,תהיינה ,f g hל - פונקציות מ- +.

)אם : הוכיחו ישירות מההגדרה ) ( ( ))f n g n= Ο ו -( ) ( ( ))g n h n= Ο אז ( ) ( ( ))f n h n= Ο.

:5שאלה

)ם כי אהוכיחו )f g= Ο , אזי1 1

( ) ( )n n

i i

f i g i= =

⎛ ⎞= Ο⎜ ⎟⎝ ⎠

∑ ∑

:6שאלה

1: נגדיר) 1

log( )

( )n

ii n

f n=

= ∑.

) )א ) (log( ))f n n= Θ ) )ב ) ( log( ))f n n n= Θ ⋅ ) )ג ) ( log( ))f n n n= Θ ⋅ .אף אחת מהתשובות אינה נכונה )ד

: נגדיר) 2log( )

( ) log( )n

i n

f n i=

= ∑.

) )א ) ( log(log( )))f n n n= Θ ⋅. ) )ב ) ( log( ))f n n n= Θ ⋅. ) )ג ) ( log( ))f n n n= Θ ⋅. ) )ד ) ( log(log( )))f n n n= Θ ⋅. .אף אחת מהתשובות אינה נכונה )ה

:7שאלה : תנו חסם הדוק לזמן ריצת הפונקציות הבאות

.אint func (int n)

int sum, i, j ,k; sum = 0; for(i= log( )n ; i<= n ; i++) for(j=1; j<= i; j++) for(k=1; k<=n*n; k+= i*i) sum++; return sum;

- 3 -

.בint func (int n)

int sum, i, j ,k; sum = 0; for(i = 1; i ≤ n; i *= 2) for(j = 1; j ≤ i; j *= 2) for(k = 1; k <= j; k *= 2) sum++; return sum;

.גcin>>n; for(i=n; i>=1; i--) x=1;

while (x<i) x *= 2;

while (x>2) x = sqrt(x);

. ד

int func (int n) int sum, i, j; sum = 0; for(i = 1; i <= log( )n ; i++) for(j = 0; j < n; j+=i) sum++; for(i = 1; i< n; i++) j = i; while(j > 2) sum++; j = j ; return sum;

. Θ(1) לוקחת -ו, log הניחו שכל קריאה לפונקציות :ההער

- 4 -

.הint func (int n)

int sum, i, j, k, p; sum = 0; for(i = 1; i <= n; i++) for(j = 0; j < n; j+=i) sum++; for(i = 1; i<= log( )n ; i++) for(j = 1; j <= n; j++) for(k = 1; k <= i; k++) for(p = 1; p <= k; p++) sum++; return sum;

. Θ(1)לוקחת , log הניחו שכל קריאה לפונקציה :ההער .ו

int func (int n) int sum, i, j, jump; sum = 0; jump = 1; for(i = 0; i < log( )

nn ; i++)

for(j = log( )i n⋅ ; j < ( 1) log( )i n+ ⋅ ; j+=jump) sum += j; jump *= 2; return sum;

:ותהער . Θ(1)לוקחת , logהניחו שכל קריאה לפונקציה •)log - מתחלק בn -הניחו ש • )nללא שארית . .ז

int func (int n) int sum, i, j ,k; sum = 0;

for(i= log( )n ; i<= n ; i++) for(j=1; j<= i; j++) for(k=1; k<=n*n; k+= i*i) sum++; return sum;

- 5 -

:8שאלה ולא שם עין על , האב לרגע איבד ריכוז. לים, בן השלוש, הלכו אב ובנו, ביום סגרירי עם ראות לקוייה

.אך לא ראה את הבן, ואז ימינה, הוא הסתכל שמאלה. לפתע גילה שבנו אבד. הילדלמציאת הבן (ריתם הבא וחשב על האלגו, לא ידע אם להתחיל ללכת לכוון צפון או דרום, האב אובד עצות

):האובד1 .i ← 1 כל עוד לא נמצא הבן. 2

. צעדים לכוון דרוםi2 צעד 2.1 . חזור לנקודת המוצא2.2 . צעדים לכוון צפוןi2 צעד 2.3 . חזור לנקודת המוצא2.42.5 i ← i + 1

, ומרגע תחילת החיפוש הוא נותר במקומו, )םצפון או דרו(הניחו שמנקודת המוצא הילד נע לאחד הכוונים

.עד שאביו מוצא אותו הוא מספר הצעדים בין נקודת המוצא לנקודה nכאשר , nנתחו את יעילות האלגוריתם כפונקציה של )א

.בה מצא האב את בנו . O(n)תארו אלגוריתם לפיו ימצא האב את בנו ביעילות של )ב .O(n)כדי להראות שהיעילות היא אכן נתחו את יעילות האלגוריתם שנתתם ) ג

:9שאלה :ממיין אותו) Mנקרא לו (האלגוריתם הבא . איבריםn של Aנתון מערך

n < 3אם

I ( נמיין אתAונסיים. ישירות . :אחרתI( נחלק אתAתתי מערכים 3 - ל A1 ,A2 ,ו- A3 בגודל n/3כל אחד .

II( נמיין אתA1 בעזרת אלגוריתם Bubble Sort. III( נמיין אתA2 בעזרת אלגוריתם Heap Sort. IV( נמיין אתA3ברקורסיה . V( נמזג אתA1 ,A2 ,ו- A3 למערך ממוין בעזרת אלגוריתם הפועל בזמן ליניארי במספר האיברים

.הכולל . Mתארו נוסחה רקורסיבית המתארת את זמן הריצה של האלגוריתם . א ).Master Theorem(יה בעזרת משפט האב פתרו את הנוסחה הרקורסיבית שהגעתם אל. ב

- 6 -

:10שאלה , left = 0 לזמן הריצה של הפונקציה כאשר היא נקראת עם הפרמטרים Θחשבו חסם הדוק במונחי

: לפי ההנחיות הבאותright = n−1 -ו .הסבירו תשובתכם. הצבה חוזרתכתבו נוסחת נסיגה לזמן הריצה ופתרו אותה על ידי

אולם יש להראות את השלבים השונים של ההצבה , ח את נכונות הפתרון באינדוקציהאין צורך להוכי .החוזרת

void Sort(int A[], int left, int right) int p; If ( left < right) p = (right − left + 2)/3; Sort(A,left, left + p − 1); Sort(A, left + p, left + 2*p − 1); MergeSort(A, left + 2*p, right); Merge3(A, left, left + p, left + 2*p, right);

:כאשר• MergeSort(A,i,j) היא הפונקציה שראינו בכיתה שממיינת את המערך A בין

. שלמדנוMergeSort בעזרת אלגוריתם j - לi הגבולות • Merge3(A,i,j,k,m) היא פונקציה הממזגת שלושה חלקים ממוינים הנמצאים

, m - לk -ו, k−1 - לj −1 ,j - לi בין הגבולות . ויעילותה ליניארית במספר הנתונים הכולל שהיא ממזגת

)אם אחד החלקים ריק אז הפונקציה ממזגת את שני החלקים הנותרים (

:11שאלה

).nבגודל , Bתוך שימוש במערך עזר (A הנתונים במערך שונים איברים nהאלגוריתם הבא ממיין . המערך ממויןn ≤ 1אם .1 ,אחרת .2

).A[1 ... n/2]ת כלומר א(מיין ברקורסיה את חצי המערך השמאלי .2.1 ).A[n/2+1 ... n]כלומר את ( את חצי המערך הימני HeapSortמיין בעזרת .2.2 i = 1, …, n/2עבור .2.3

. A[i] -מצא בעזרת חיפוש בינארי את מספר האיברים בחצי המערך הימני הקטנים מ .2.3.1 .j -נסמן מספר זה ב

2.3.2. B[i + j] = A[i] i = n/2+1, …, nעבור .2.4

- מספר האיברים בחצי המערך השמאלי הקטנים ממצא בעזרת חיפוש בינארי את .2.4.1A[i] .נסמן מספר זה ב- j.

2.4.2. B[i – n/2 + j] = A[i] .A - לBהעתק את מערך .2.5

.1ל תאי מערך מתחילים באינדקס "באלגוריתם הנ: הערה

. באלגוריתם זה2.4 - ו2.3הסבירו בקצרה מהו תפקידם של צעדים )א .נתחו את יעילות האלגוריתם במקרה הגרוע )ב

- 7 -

:12שאלה :nואת גודלו , של מספרים שלמים [ ]Arrהמקבלת מערך , נתונה הפונקציה הרקורסיבית הבאה

int func (int Arr[], int n)

int i, j, sum=0; if(n<=2) return 0; else

for(i = 0; i < n ; i++) func(Arr+ i n⋅ , n );

for(j = i n⋅ ; j < ( 1)i n+ ⋅ ; j++) sum += Arr[j];

return sum;

. Θ(1)לוקח , n של חישוב הניחו שכל :ההער

.ל"ת הפונקציה הניגה המתארת את סדר גודל מספר הפעולות שמבצעכתבו את נוסחת הנס. א .ל"הפונקציה הנציירו את עץ הקריאות הרקורסיביות שיתקבל מהרצת . ב

.וכן לפרט נתונים המעידים על מבנה העץ, יש לצייר את העץ כך שתובן צורתו: הערה מהם ) שציירתםמתוך מבנה העץ(ים יש לתאר את השיקול. ל"פונקציה הנתנו חסם הדוק לזמן ריצת ה. ג

.הסקתם חסם זה

:13שאלה 1 -ניתן להניח ש( מספרים n של Aהאלגוריתם הבא ממיין מערך. kנתון פרמטר k n< ≤:(

nאם .1 k≤ ,וסיים, מיין את המערך במיון בועות. n בגודל , A1, ..., Ak תת מערכים k - לAנחלק את .2

k אם ( כל אחדnאינו מתחלק במדויק ב - k , ).אז תת המערך האחרון יכיל פחות אברים

. תתי המערכיםk -נמיין ברקורסיה את כל אחד מ .3 עתה נמזג את ; הממויןA3 עתה נמזג את תוצאת המיזוג עם ; הממוייןA2 הממויין עם A1נמזג את .4

באיטרציה האחרונה נמזג את תוצאת המיזוג של . וכך הלאה, הממויןA4עם תוצאת מיזוג זו A1, A2, ..., Ak-1 עם Akהממויין .

nכתבו את נוסחת הנסיגה המתארת את סדר גודל מספר הפעולות שמבצע האלגוריתם כפונקציה של ) א .k -ו

הרקורסיביות שיתקבל מהרצת האלגוריתם ציירו את עץ הקריאות) ב

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

- 8 -

:14שאלה int Func(int* arr, int n, int i)

int j, k, sum = 0; if (n < i)

for(j=0; j<n; j++) sum += arr[j];

else for(j=0; j<i; j++) sum += Func(arr+ j*(n/i) , n/i, i);

for(k = j*(n/i);k < (j+1)*(n/i); k++) sum += arr[k];

return sum;

1: הניחו ש:ההער i n< .i הינו חזקה של nוכי , > כתבו את נוסחת הנסיגה המתארת את סדר גודל מספר הפעולות שמבצע האלגוריתם ) א

.i של וnכפונקציה של

ציירו את עץ הקריאות הרקורסיביות שיתקבל מהרצת האלגוריתם ) בגובה : כגון, עידים על מבנה העץלפרט נתונים המיש כן כמו . יש לצייר את העץ כך שתובן צורתו:הערה

.'העץ מספר קודקודים ברמה וכד מהם הסקתם חסם ) מתוך מבנה העץ(יש לתאר את השיקולים . תנו חסם הדוק לזמן ריצת האלגוריתם) ג .זה ?nכפונקציה של , הגרוע ביותר יתקבל שמן הריצה iעבור איזה ערך של ) ד

): הואזמן הריצה , ________ = i: עבור ) (__________)T n =Θ

?nכפונקציה של , הטוב ביותר יתקבל שמן הריצה i עבור איזה ערך של ): זמן הריצה הוא, ________ = i: עבור ) (__________)T n =Θ

- 9 -

:15שאלה רות הן מהתחום כאשר הספ, ספרותnכל אחד כולל , שני מספרים טבעיים גדולים מאודx,yיהיו

, nכאשר כל מערך באורך , y - וxשני המספרים האלה נשמרים בשני מערכים הנקראים . 9,…,0,1). n ועד 1 -נניח שתאי המערכים ממוספרים מ( של המערך i - של כל מספר נמצאת בתא הi -והספרה ה

. x = [3,4,5,6] אז הוא ייוצג כך במערך x = 3456כך למשל אם

בכל . x⋅yעליכם לבדוק את יעילותם של שלושה אלגוריתמים שתפקידם לחשב את המכפלה בשאלה זו .nהמקרים ציינו את יעילות האלגוריתמים כפונקציה של

ס " באופן דומה לשיטה הרגילה שלומדים בביהx⋅yמה תהיה יעילותו של אלגוריתם שיכפיל את )א

.הסבירו תשובתכם? לכפל מספרים

הניחו בסעיף זה ובסעיף . כפי שאפשר לראות בציור הבאn/2י חלקים באורך לשנy ואת xנחלק את )בזוגי אז חלק אחד - איnאולם אם במקרה (2 - מתחלק בn ולכן 2 הוא חזקה כלשהי של n -הבא ש

).יכיל ספרה אחת יותר

a b

n/2 ספרות n/2 ספרות

x

c d

n/2 ספרות n/2 ספרות

y

חציו השמאלי cובדומה , x חציו הימני של המערך b - וx הוא חציו השמאלי של המערך aכאשר

. y חציו הימני של המערך d ואילו yשל המערך n: שימו לב שאז מתקיימות הזהויות / 2 n / 2x a 10 b, y c 10 d= ⋅ + = ⋅ +

.x = a⋅104 + bואכן מתקיים . a = 1234 ,b = 5678 אז x = 12345678 אם :דוגמה

.y = c⋅104 + dומתקיים , c = 3456 ,d = 0000 אז y = 34560000אם , בדומה

: בעזרת הנוסחה הבאהx⋅yכעת אפשר לכתוב אלגוריתם רקורסיבי שיחשב את המכפלה

n n / 2x y (a c) 10 (a d b c) 10 (b d)⋅ = ⋅ ⋅ + ⋅ + ⋅ ⋅ + ⋅

.ה ישירות ואז מחשבים את המכפלn = 1כאשר תנאי העצירה הוא

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

:אולם הפעם בעזרת הנוסחה הבאה, הפעם שוב נחשב את המכפלה באופן רקורסיבי) ג

n n / 2x y (a c) 10 ((a b) (c d) a c b d) 10 (b d)⋅ = ⋅ ⋅ + + ⋅ + − ⋅ − ⋅ ⋅ + ⋅

כתבו נוסחת נסיגה המתארת את יעילות האלגוריתם הרקורסיבי היעיל ביותר המיישם את הרעיון

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

- 10 -

:16שאלה .את הנתון המינימאלי מתוך נתונים במערך ברקורסיה וצאתנתונה הפונקציה הבאה המ

int Min(int* Arr, int size) int ind, SortedInd; if (size == 1) return Arr[0]; else ind = Random(size); SortedInd = Partition(Arr, size, ind); if (SortedInd == 0) return Arr[0]; else return Min(Arr, SortedInd-1);

:הערות

ומחזירה מספר טבעי , num מקבלת כקלט מספר טבעי ,int Random(int num): ההפונקצי • ). num-1( לבין 0אקראי בתחום בין .Θ(1) -פונקציה זו פועלת ב

מקבלת כקלט כתובת ,int Partition(int* Arr, int size, int ind): הפונקציה •

. שהוא אינדקס חוקי במערךindומספר טבעי נוסף , sizeאת גודלו , Arrהתחלה של מערך ומחזירה את האינדקס בו ,Arr[ind] סביב הנתון Arr על המערך Partitionהפונקציה מבצעת

. נמצא בסוף הפעולה) Partition -הנתון שסביבו בוצע ה(הוא . שהוצג בכיתהPartition -י האלגוריתם ל"פונקציה זו פועלת עפ

.של האלגוריתם) worst case (הגרוע ביותרהדוק לזמן הריצה מצאו חסם ) א .של האלגוריתם) best case (הטוב ביותרמצאו חסם הדוק לזמן הריצה ) ב .של האלגוריתם) average case (ממוצעהמצאו חסם הדוק לזמן הריצה ) ג

:17שאלה n()n(T(: בהינתן אלגוריתם אשר מקיים. א 2

best Ω= . ?n(Tworst(מה ניתן להסיק על

n()n(T(: בהינתן אלגוריתם אשר מקיים. ב 2best Ο= .

?n(Tworst(מה ניתן להסיק על

- 11 -

:18שאלה :n ואת גודל המערך A מערך מקבל כקלטשאלגוריתם נתון

Algorithm Alg (A, n) for (i=1 to n) if ( F1(A,i) == TRUE ) F2(A,i);

:כאשר1 (F1 את היא פונקציה המקבלת כקלטAמספר שלם וi מחזירה וTRUE או FALSE .

nc הוא זמן ריצתה i ). קבוע הוא cכאשר ( ⋅

2 (F2 את המקבלת כקלטפונקציה היא Aפר שלם מס וi. ' הואזמן ריצתה logc n i⋅ ). הוא קבועc‘כאשר ( ⋅

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

:19שאלה :נתון האלגוריתם הבא

Algorithm A (int n) F1(n); F2(n); F3(n);

.F1, F2, F3וקורא לשלוש פונקציות , n מקבל כקלט מספר שלם וחיובי Aהאלגוריתם

),(),()(-הפונקציות ב זמני הריצה של שלש נסמן את 321 nTnTnT ואת זמן הריצה של כל , בהתאמה ש נתון. nTA)( -האלגוריתם ב

)()(),log()(),()( 2321 nOnTnnnTnnT =Θ=Ω=

?החסמים הבאים בהכרח נכונים ואילו אינם בהכרח נכוניםארבעת אילו מבין . נמקו בקצרה את תשובותיכם

)1 ()()( nnTA Ω= )2 ()log()( nnnTA Ω= )3 ()log()( nnnTA Θ=

)4( )()( 2nOnTA =

- 12 -

:20 שאלה של עץ בינארי InOrder -ו, PreOrderתם המקבל שני מערכים המכילים את סדרות המעבר נתון אלגורי

.האלגוריתם משחזר ומחזיר את העץ ממנו התקבלו הסדרות. כלשהו ואת גודלם

.T של עץ בינארי PreOrder - מערך המכיל את סדרת ה– [ ]pre :קלט in[ ] –מערך המכיל את סדרת ה - InOrder עץ בינארי שלT. size – מספר הצמתים בעץ T) שהוא גם גודל המערכים.( .T העץ :פלט

:האלגוריתם

)size = 0(אם . 1 . החזר את העץ הריק1.1 :אחרת. 2

2.1 )[0]pre(T.data

pre (place[0] מופיע בוinהמקום במערך (2.2

T.left ) :קרא ברקורסיה עם (2.3

T.right: ) קרא ברקורסיה עם (2.4

.T החזר את 2.5 :הערות

]: הסימון. 1 , , ]Arr i jK ,המערך של -מייצג את תתArr מהאינדקס i עד האינדקס j) כולל .( .יי חיפוש ליניאר" ממומשת ע2.2פוש בשורה הניחו שפעולת החי. 2 .הניחו שהנתונים בעץ שונים זה מזה. 3 :מריצים את האלגוריתם עם הקלט )א

(iציירו את העץ המתקבל מפלט האלגוריתם :

(ii הנוצר מהרצת האלגוריתם , ציירו את עץ הקריאות הרקורסיביות)בכל צומת ).על הקלט לעיל . עבור הקריאה אותה הוא מייצגsizeציינו את ערכו של המשתנה ותבעץ הקריא

.Ω וגם O הוכיחו גם .של האלגוריתם) worst case( הגרוע ביותר מצאו חסם הדוק לזמן הריצה ) ב .Ω וגם O הוכיחו גם .של האלגוריתם) best case( הטוב ביותר מצאו חסם הדוק לזמן הריצה ) ג

[ 1, , 1],[ 1, , ( 1)],

1

pre place sizein place sizesize place

+ −+ −

− −

K

K

[1, , ],[0, , ( 1)],

pre placein placeplace

−K

K

[3,1, 4, 2,6,5,7,8][1, 4,3,5,7,6, 2,8]

8

preinsize

===

- 13 -

ניתוח אלגוריתמי חיפוש ומיון

:1שאלה האלגוריתם הבא הוא וריאציה על האלגוריתם . מספרים שונים וממוין בסדר עולה n הכולל Aנתון מערך

:לחיפוש בינארי

במקום לבדוק רק את הערך באינדקס , בכל שלב2n , את הערך בכל אחד מהאינדקסים נבדוק

, 2 ,3 ,..., ( 1)n n n nkk k k k

−.

. נעצור ונחזיר את האינדקס שלו–אם באחד מהם הערך שווה לערך שמחפשים . נפעיל את האלגוריתם באופן רקורסיבי רק על הקטע המתאים–אחרת

.ובתכםהוכיחו תש? k - וnמה יהיה זמן הריצה של אלגוריתם זה במקרה הגרוע כפונקציה של

:2שאלה A, נתוניםnאזי במקרה הגרוע של מיון , הוא אלגוריתם מיון הפועל במודל ההשוואותAהוכיחו כי אם

)מבצע log( ))n nΩ . השוואות⋅

:3שאלה לפי סדר הופעתם (A -תת המערך המכיל את כל המספרים הזוגיים מ. מערך של מספרים טבעייםAיהי לאו ) A -לפי סדר הופעתם ב (A -זוגיים מ-אך תת המערך המכיל את כל המספרים האי, ממוין) A -ב

. ממויןאדווק

, ממוין[10 ,8 ,4 ,2]: תת המערך של הזוגיים ([10 ,5 ,8 ,4 ,9 ,2 ,3 ,1]: יכול להיות המערךAלמשל ). לא ממוין[5 ,9 ,3 ,1]: זוגיים-ואילו תת המערך של האי

. השוואות במקרה הגרועΩ(nlog(n)) נדרשות תל במודל ההשוואו" שעל מנת למיין מערך כנוחיהוכ

:4שאלה הלקוחים מתוך התחום , איבריםmנתונים 2m,,2,1 K .

)ל ביעילות "דמבלדור טוען כי ניתן למיין את הנתונים הנ' פרופ )mΘבמקרה הגרוע . ?האם יש אמת בטענתו

- 14 -

:5שאלה - בn3 .. 0 מספרים מהתחום n ימיין Radix Sortאלגוריתם ) 1

מקום נוסףΘ(n) - זמן וΘ(n) )א מקום נוסףΘ(1) - זמן וΘ(n log n) )ב מקום נוסףΘ(n) - זמן וΘ(n log n) )ג מקום נוסףΘ(n3) - זמן וΘ(n3) )ד מקום נוסף Θ(1) - זמן וΘ(n) )ה

: נבחר באופן רנדומי הואpivot - כאשר הQSזמן הריצה במקרה הגרוע של אלגוריתם ) 2

Θ(n log n) )א Θ(n) )ב Θ(n2) )ג Θ(n log2n) )ד

מספרים n הממיין Radix Sortהיעילות הטובה ביותר האפשרית ליישום אלגוריתם ) 3

,1מהתחום 2, , 2 nK ,תוך שימוש ב- O(n)היא, וסף מקום נ: ) )א )O n . ) )ב log( ))O n n⋅. )2 )ג )O n. 2) )ד )nO.

: נבחר באופן רנדומי הואpivot - כאשר הQSזמן הריצה במקרה הטוב ביותר של אלגוריתם ) 4

.Θ(n log n) )א .Θ(n) )ב .Θ(n2) )ג .Θ(n log2n) )ד

- 15 -

לגוריתמיםכתיבת א

:1שאלה ומחזיר מצביע לעץ , T1,T2ב אלגוריתם המקבל כקלט שני מצביעים לשני עצי חיפוש בינאריים וכת

.)T2 -או רק ב, T1 -או רק ב (שני העציםופיעו רק באחד מ שכולל את כל הנתונים שהTחיפוש בינארי .כל אחד משני העצים הוא מספר הקדקודים בn כאשר O(n)יעילות האלגוריתם צריכה להיות

:2שאלה יש להכריע האם יש ביניהם .[0,1] מהקטע אחידהממשיים הלקוחים בהתפלגות מספרים nנתונים

.שני מספרים זהים

בעל סדר רון נוסףומשתמש בזיכבמקרה הממוצע תארו אלגוריתם לבעיה שרץ מהר ככל האפשר . גודל מינימאלי

.את סיבוכיות הזמן ואת סיבוכיות הזיכרון הנוסף שהוא דורשנתחו

:3שאלה - וAנקרא למערכים (כאשר כל אחת נשמרת במערך כפי שלמדנו בכיתה , נתונות שתי ערימות מקסימום

B( , וכל ערימה מכילהnכתבו אלגוריתם יעיל ככל האפשר במקרה הגרוע שממזג את שתי . איברים ).2n בגודל Cשתישמר במערך (ום יחידה הערימות לערימת מקסימ

. האיברים שונים זה מזה2n מותר להניח שכל :הערה

:4שאלה כאשר בכל קדקוד נשמר מפתח , שממומש כרגיל על ידי מצביעים לילדים Tנתון עץ חיפוש בינארי

שהם x,yושני ערכים , Tכתבו אלגוריתם שמקבל מצביע לשורש העץ . שהוא מספר שלםkeyכלשהו x -ומחזיר את המפתח שנמצא באב הקדמון המשותף הקרוב ביותר ל, מפתחות של קדקודים כלשהם בעץ

? בעץ nמה יעילות האלגוריתם שלכם כפונקציה של מספר הקדקודים . y -ול

ואילו האב הקדמון המשותף . 6 הוא 4 - ול10 -האב הקדמון המשותף הקרוב ביותר ל, בעץ הבא:דוגמה . 12 הוא 5 - ול20 -ותר להקרוב בי

12

15

20

6

8

7 10

5

2

4

- 16 -

:5שאלה הוא מספר biהמספר , כן ידוע שלכל קטע-כמו. ai < bi מתקיים i כאשר לכל (ai, bi) קטעים nנתונים

שיכולים להיות כל מספר aiאבל זה לא בהכרח נכון עבור המספרים (n2,...,1,2שלם מהקבוצה ). ממשי

. הקטעים זרים זה לזהnמודיע האם כל כתבו אלגוריתם יעיל ככל האפשר ש

?nמה יעילותו של האלגוריתם שלכם כפונקציה של

:6שאלה .העץ ממומש על ידי מצביעים לילדים. שבקדקודים שלו יש מספרים שלמיםTנתון עץ בינארי רמה אחרי רמה החל , T שידפיס את תוכן הקדקודים של OrderedLayers(Tree T)כתבו אלגוריתם

.כאשר בכל רמה יודפסו המספרים בסדר עולה מהקטן לגדול, השורשמ

.12 ,4 ,10 ,8 ,5 ,9 ,3 ,7 עבור העץ הבא יודפס הפלט הבא משמאל לימין :דוגמה

7

9 3

5

4 12

8 10

המכילים זוגות מהצורה Q1, Q2לשם כתיבת האלגוריתם השתמשו בשני תורי קדימויות מינימום ואילו המפתחות הם , )או מצביע לקדקוד( להכיל קדקוד בעץ כאשר שדה הנתונים יכול, )מפתח, נתונים(

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

• MakeEmpty( ) –לרוקן את התור . • IsEmpty ( ) – אחרת0, אם התור ריק1 מחזירה . • Insert(int key, TreeNode data) – מכניסה את הזוג (key, data)לתור הקדימויות . • Min( ) – מחזירה את הזוג (key, data)שהמפתח שלו מינימלי מבין כל המפתחות בתור . • DeleteMin( ) – מורידה מהתור את הזוג (key, data)שהמפתח שלו מינימלי מבין כל

.תור ומחזירה את הזוג כערך המפתחות ב

).אין להשתמש ברקורסיה (בגודל קבועבנוסף אתם יכולים להשתמש רק בזיכרון נוסף !כבקופסאות שחורות ובפעולות המוגדרות עליהם Q1,Q2 -האלגוריתם שלכם ישתמש ב, שימו לב

:הקדימויותבשני מימושים אפשריים של תורי של האלגוריתם במקרה הגרוע נתחו גם את יעילותו

.מינימוםת ו על ידי ערימים הקדימויות ממומשיתור. 1 ).לפי המפתח(י רשימות מקושרות ממוינות "תורי הקדימויות ממומשים ע. 2

- 17 -

:7שאלה כל : מתקיים) להיותה ערימת מינימום(אם בנוסף , ערימת מינימום ממוינת חלקיתערימת מינימום תקרא

1iוזאת לכל , (i-1) -נתונים ברמה ה גדולים מכל הi -הנתונים ברמה ה ≥. .0 -השורש נמצא ברמה ה: תזכורת

האלגוריתם משנה את סדר הנתונים . n ואת גודלו [ ]Aכתבו אלגוריתם יעיל ככל האפשר המקבל מערך

.כך שבסוף האלגוריתם המערך ייצג ערימת מינימום ממוינת חלקית, במערך .לות של האלגוריתם שכתבתםנתחו את היעי

:הערות

.הניחו שכל הנתונים במערך שונים זה מזה. 12 הוא מספר מהצורה n -הניחו ש. 2 1kn = 1kעבור , − . כלשהו≤

:8שאלה n -הניחו ש. nו ואת גודל, של מספרים [ ]Arr המקבל כקלט מערך ,כתבו אלגוריתם יעיל ככל האפשר

2: הוא מהצורה 1kn = −. ,i) 0,1 -אשר במקום ה, kהאלגוריתם מייצר ומחזיר מערך בגודל , ( 1)i k= −K( ,2 -יופיע המספר הi

. Arrבגודלו מבין המספרים במערך במערך התוצאה יהיה 1בתא ). המינימאלי( בגודלו 1 - של מערך הפלט יהיה הנתון ה0בתא , כלומר .וכך הלאה, בגודלו4 - במערך התוצאה יהיה הנתון ה2בתא . בגודלו2 -הנתון ה

:9שאלה וכן מספר , nאת גודלו , המקבל מערך של מספריםMakeMaxHeap(Arr[], n, d)כתבו אלגוריתם

הרמות d -אשר ב, מקסימוםדי שייצג ערימת האלגוריתם משנה את סדר האיברים במערך כ. dנוסף . הראשונות בה יופיעו האברים הגדולים ביותר

.Θ(n)על האלגוריתם לרץ בזמן . קטן ממש מגובה העץd -ניתן להניח ש: הערה

המערך MakeMaxHeap(Arr, 6, 2) לאחר הקריאה לאלגוריתם Arr = [5, 3, 2, 1, 4, 8]למשל אם

Arr יכול להראות Arr = [8, 4, 5, 1, 2, 3] ,ולייצג את ערימת המקסימום הבאה:

8

2

4

1

5

3

בשתי הרמות הראשונות מופיעים שהם האיברים הגדולים 4,5,8

. ביותר במערך

- 18 -

:10שאלה :נתונים המבנים הבאים

struct Tnode struct ArrayData int data; int x; Tnode* left; int y; Tnode* right; ; ;

:נתונה הפונקציה הבאה, כמו כן

ArrayData* What(Tnode* root, int* size) int num; ArrayData* resArr; num = NumNodes(root); resArr = new ArrayData[num]; *size = num; Unknown(root, 0, resArr); return resArr;

של אברים מטיפוס (ומייצרת מערך , לשורש של עץ בינאריrootל מקבלת מצביע "הפונקציה הנArrayData(, ומעדכנת את , הפונקציה ממלאת את המערך בערכים. מתים בעץשגודלו מספר הצ

. sizeגודלו דרך המשתנה

:המוגדרת באופן הבא ,Unknown ת העזרבפונקציעושה שימוש whatהפונקציה

int Unknown(TNODE* root, int y, ArrayData* resArr) int sizeL, sizeR; if (root = NULL) return 0; else (resArr[0]).x = root->data; (resArr[0]).y = y; sizeL = Unknown(root->left, y+1, resArr+1); sizeR = Unknown(root->right, y+1, resArr+1+sizeL); return (1 + sizeL + sizeR);

ומערך , yפרמטר קלט נוסף , לשורש של עץ בינארי rootמקבלת מצביע Unknownהפונקציה כל אחד מטיפוס (בערכים resArrהפונקציה ממלאת את המערך . resArr) בגודל מספיק(

ArrayData .( .root מחזירה את מספר הצמתים בעץ עליו מצביע Unknownהפונקציה , משיקולי יעילות

- 19 -

: נתון העץ הבא א i ( מלאו את המערך המתקבל כתוצאה מהרצתWhat(root) ii ( ערכים במערך הפלט של הפונקציה התארו באופן כללי את חוקיותwhat ,כפונקציה של העץ T

.אותו היא מקבלת כקלט

ה את ריצת הפונקציה קהמח, )ללא רקורסיה (גרסה איטרטיביתהיעזרו במחסנית על מנת לכתוב ב Unknown.

:הערות .הקפידו לכתוב אלגוריתם ברור וחד משמעי .1 ).כפי שהוגדר בכתה(קוד -אודויאו בפס, )++C/C(תן לממש את האלגוריתם בשפה עילית ני .2 . במחסנית כבקופסה שחורההשתמשו .3

):מתחילת השאלה (what המבצעת את הפעולה ההפוכה של הפונקציה what-1 כתבו את הפונקציה ג

Tnode* what-1(ArrayData* Arr, int size);

. sizeואת גודלו , ArrayDataשל אברים מטיפוס Arrערך מקבלת מwhat-1הפונקציה נקבל חזרה את whatכך שאם נפעיל עליו את הפונקציה , Tהפונקציה משחזרת ומחזירה עץ בינארי

).אשר עבורם יש יותר מעץ אחד כזה, שימו לב שייתכנו מערכי קלט (Arrהמערך

8

2 1

5 4 3

root

x

y

Index: 0 1 2 3 4 5

- 20 -

:11שאלה המכיל את AVLויוצר מהם עץ , איבריםnכל אחד עם , AVLתארו אלגוריתם ליניארי המקבל שני עצי

). האיברים שונים זה מזה2nהניחו שכל ( האיברים 2nכל

:12שאלה , כלומר( המופיעים בסדר ממוין A = [a1, a2,..., an]מערך של מספרים שונים נתון

1 2 na a a≤ ≤ ≤K .( בו יהיו נתוני המערך שהעלים, חוקי2-3ברצוננו לייצר ולהחזיר עץ A.

. בשני תוריםלשם כתיבת האלגוריתם השתמשו . כתבו אלגוריתם יעיל ככל האפשר לפתרון הבעיה ,Make-Empty( ),Is-Empty( ) ,EnQueue(data) :הבאות ניתן להפעיל את הפעולותתור על

DeQueue( ) ,Front( ) , וכן את הפעולהNumElems( )נים בתור ברגע שמחזירה את מספר הנתו . הפעלתה

בגודל אתם יכולים להשתמש רק בזיכרון נוסף לשני התורים ולעץ אותו אתם מייצרים , Aלמערך בנוסף ).A ואין לשנות את המערך אין להשתמש ברקורסיה (קבוע

:יכול להיווצר העץ, A = [1, 3, 4, 6, 7, 8, 8, 9, 10, 13, 15] עבור המערך למשל

: הערה :בכל צומת פנימי בעץ אותו אתם מייצרים יש לעדכן רק את השדות

Right-Child, Mid-Child, Left-Child, ולילד הימני לילד האמצעי, צביעים לילד השמאלימכילים מה ). min1, min2, min3אין צורך לעדכן את השדות (בהתאמה

. זמןΘ(1)שכל פעולת תור לוקחת נחה של האלגוריתם במקרה הגרוע בהנתחו את יעילותו

.אלגוריתםהנדרש ל הזיכרוןנתחו את

887

4 6

1 3

9 10

13 15

- 21 -

:13שאלה .2חזקות של הם n,kכאשר , k ≤ n ≥ 1ומספר , מספרים שלמים כלשהםn הכולל A[n]נתון מערך

). C -כפי שמקובל ב n-1 ,... ,1 ,0 -בולא (n,…,1,2 -הניחו שתאי המערך ממוספרים ב

:ת הפונקציות הבאותכן נתונו-כמו

• int Select(int A[], int left, int right, int i) –הפונקציה מחזירה את האיבר ה - i בגודלו

. 1−אם אין כזה איבר הפונקציה תחזיר . right - וleft שבין הגבולות Aמערך של - בתת

• void Partition(int A[], int left, int right, int x, int i) –חה היא ש ההנ- x הוא האיבר .right - לleft בין הגבולות Aמערך של - בגודלו בתתi - ה

: באופן הבאright - לleftמערך שנמצא בין הגבולות - הפונקציה מסדרת את האיברים בתת את כל המספרים הקטנים , מערך הזה- בתתleft + i −1 - במקומו הx היא שמה את

ממנו מימינו ) או שווים(ואת כל הגדולים , ממנו משמאלו)או שווים ( ).הפונקציה אינה משנה את יתר המערך (

. במקרה הגרועΘ(right−left + 1) היא Select, Paritition היעילות של הפונקציות :הנחה

:אז. A = (7, 12, 5, 9, 4, 27, 1, 15) - וn = 8יהיה :דוגמה

Select(A,1,8,6)בגודלו ב6 -כי זה האיבר ה, 12ר את תחזי - A 8 - ל1 בין הגבולות.

Partition(A,1,8,12, 6) תשנה את המערך Aלמשל באופן הבא :A = (7, 5, 9, 4, 1, 12, 27, 15).

: אזA = (7, 12, 5, 9, 4, 27, 1, 15)ואם שוב נתון Select(A, 2,5,3) (12,5,9,4)המערך - בגודלו בתת3 - כי הוא האיבר ה9 תחזיר את .

. A = (7,5,4,9,12,27,1,15): ישונה למשל כךA אז המערך Partition(A,2,5,9,3) -ואם נקרא ל ). שינתה מודגשPartition -מערך ש התת(

. כבקופסאות שחורותPartition - וSelectיש להשתמש בפונקציות

, Select, Partitionנקציות המשתמש בפובמקרה הגרוע יעיל ככל האפשר אלגוריתםכתבו : באופן הבאAכדי לסדר את המספרים במערך

, וכך הלאה, A[2k] בגודלו יהיה בתא 2k -האיבר ה, A[k] בגודלו יהיה בתא k -האיבר ה

n1לכל , A[ik] בגודלו יהיה בתא ik -כאשר באופן כללי האיבר ה ik

≤ ≤.

A[1..k−1] בגודלו יהיו בתאים k -מהאיבר ה) או שווים(כל המספרים שקטנים , כן-כמו 2k - וקטנים מהאיבר הk -מהאיבר ה) או שווים(האיברים שגדולים , )לאו דווקא ממוינים(

. וכך הלאהA[k+1..,2k−1]בגודלו יהיו בתאים

. תשובתכםוכיחוה? k - וn כפונקציה של מה יעילות הפונקציה שכתבתם במקרה הגרוע

- 22 -

:14ה שאל :MergeSortנתונה הפונקציה הבאה המיישמת ברקורסיה את אלגוריתם המיון

void MergeSort(int* arr, int size) int mid, i; int* res; if (size == 1) return; else mid = size/2; MergeSort(arr, mid); MergeSort(arr+mid, size-mid); res = Merge(arr, mid, arr+mid, size-mid); for(i=0; i<size; i++) arr[i] = res[i]; delete [ ]res;

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

:הפונקציה משתמשת בפונקצית העזרint* Merge(int* A1, int s1, int* A2, int s2);

חדשלתוך מערך , ל"הפונקציה ממזגת את שני המערכים הנ. ואת גודלםממויניםהמקבלת שני מערכים .)שהיא מקצה( .המחכה את ריצת הפונקציה לעיל, )ללא רקורסיה (גרסה איטרטיביתעל מנת לכתוב עזרו במחסנית יה

:הערות .ריתם ברור וחד משמעיהקפידו לכתוב אלגו .4 ).כפי שהוגדר בכתה(קוד -או בפסאודו, )++C/C(ניתן לממש את האלגוריתם בשפה עילית .5 .קופסה שחורהיש להשתמש במחסנית כב .6 .י הממשק המוגדר לה"עפ, Mergeהשתמשו בפונקציה .7

:הגדרת הטיפוס של הנתונים שיכנסו למחסנית

struct StackData ______________________ ______________________ ______________________

;

- 23 -

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

).data -ול, לבן הימני שלו, לכל צומת יש גישה לבן השמאלי שלו(

, בגודלו בערימה הוא המקסימלי1 -האיבר ה( בערימה בגודלו k-נתעניין בחסימת גודלו של האיבר ה ).כמובן

:כתוב אלגוריתם ליישום הפונקציה

bool IsBiggerThanKth( HEAP root, int n, int k, int x) .k -ו, xועוד שני מספרים , n –את גודלה , root –הפונקציה מקבלת ערימת מקסימום

.x - בגודלו בערימה קטן או שווה לk - ה האיבר⇔ trueעל הפונקציה להחזיר n=6 ,k=3 ,x=2: וכן: כך למשל אם הערימה

.2- אך הוא אינו קטן או שווה ל6היות שהאיבר השלישי בגודלו הוא , falseהפונקציה תחזיר

:דרישות מימוש ).n -בלי תלות ב (O(k)על האלגוריתם לרוץ ביעילות . 1 . זיכרון נוסף בלבדθ(1) - ובQעל הפונקציה להשתמש בתור . 2

:הוא מספק את הפעולות הבאות בלבד, אין צורך לממש את התור

• MakeQ(size) –יוצרת תור ריק שיכול להכיל לכל היותר size נתונים . • IsEmpty( ) – מחזירה trueם התור ריק" אם. • EnQ(data) –ת מכניסה אdata אין חשיבות לטיפוס של ( לתורdata.( • DeQ( ) –ומחזירה אותו, מוציאה את האיבר שבראש התור. • Qsize( ) –מחזירה את מספר האברים הממתינים בתור . קטן או לא בגודלו בערימה k - ניתן לקבוע בוודאות שהאיבר הx - אברים גדולים מkאם מגלים : רמז

. x -שווה ל

9

7 1

4 6 0

- 24 -

:16שאלה : עם הפעולות הרגילותQueue –ו שמוגדר לכם טיפוס נתונים המופשט תור הניח

Make-Empty( ), Is-Empty( ) ,Enqueue(data) ,Dequeue( ) ,Front( )כפי שהוגדרו בכיתה . :לא רקורסיביתכתבו פונקציה ) א

Merge(Queue Q1, int n1, Queue Q2, int n2) . בהתאמהn2 - וn1ואת מספר הנתונים בכל אחד מהם , Q1, Q2שני תורים כקלט מקבלת הפונקציה

של מספרים כך שהמספר הקטן נמצא בראש התור והמספר ממוינתסדרה בכל אחד משני התורים יש . הגדול בסוף התור

Q2ואילו התור , המספרים משני התוריםכל סדרה ממוינת המכילה את Q1בסיום הפונקציה יכיל התור .נקציה שלכם יכולה להשתמש פרט לתורים רק בזיכרון נוסף בגודל קבועהפו. יהיה ריק

.הפונקציה שלכםנתחו את יעילות : הבאהלא רקורסיביתה פונקציהעל מנת לכתוב את ה', השתמשו בפונקציה שכתבתם בסעיף א) ב

Sort(Queue Q, int n) .מכיל סדרה כלשהי של מספריםהתור .nואת מספר הנתונים בו , Qהפונקציה מקבלת כקלט תור

. ובזיכרון נוסף בגודל קבועי עזרתור בשניממיינת את המספרים תוך שימוש הפונקציה . כאשר בראש התור נמצא הנתון המינימלי, את הקלט הממויןQבסיום הפונקציה יכיל התור

)יעילות על הפונקציה לרוץ ב log( ))n nΘ ⋅.

:17שאלה . n באורך Lונתון מערך ריק , A = [a1, a2,..., an]ערך של מספרים שונים מנתון

ai - של האיבר הקרוב ביותר לA את האינדקס במערך L[i] יש לחשב לתוך A - בaiעבור כל איבר

במילים אחרות. משמאלו שקטן ממנוL[i] = max j | j < i ∧ aj < ai

.L[i] = -1אז ) ai - גדולים מa1, a2, ..., ai-1כלומר כל האיברים (אם אין אינדקס כזה

הוא המערךAלמשל אם 3 6 8 2 7 10 12 9 11

הואLאז המערך -1 1 2 -1 4 5 6 5 8

.1 - מתחילים בAשימו לב שהאינדקסים במערך

Sמחסנית לשם כתיבת האלגוריתם השתמשו ב. כתבו אלגוריתם יעיל ככל האפשר לפתרון הבעיה

-Make-Empty( ),Is :הבאות ניתן להפעיל את הפעולותמחסנית על . במערךינדקסיםאשאבריה הם Empty( ) ,Push(data) ,Pop( ) , וכןTop( )שמחזירה את הערך שבראש המחסנית בלי להורידו .

אין להשתמש (בגודל קבועאתם יכולים להשתמש רק בזיכרון נוסף ולמחסנית L - וAלמערכים בנוסף

).Aאין לשנות את המערך וברקורסיה

: רמז ).a2( החל מהאיבר השני A זמן ותוך מעבר אחד על המערך Θ(n) -אפשר לבצע זאת ב • . Push (1) - וL[1] = -1למטרת אתחול יש לבצע •

- 25 -

:18שאלה nועץ בינארי עם , מספרים שלמים כלשהםnכתוב פונקציה יעילה ככל שתוכל המקבלת מערך המכיל

. בעץ זה הערכים בצמתים לא מעודכנים). העץ לאו דווקא מלא(רים בסדר כלשהו צמתים מסוד. המכיל את כל אברי המערך, על הפונקציה לעדכן את ערכי הצמתים בעץ כך שיתקבל עץ חיפוש בינארי

.שים לב הפונקציה לא תשנה את מבנה העץ : והעץ הוא מהמבנה[8 ,2 ,1 ,3]: אם המערך הוא, למשל

: על הפונקציה לעדכן לו את הערכים באופן הבא .הוכיחו שיש סידור חוקי יחיד של הצמתים בעץ) א .כתבו פסאודו קוד עבור הפונקציה הנדרשת) ב .הוכח שהאלגוריתם שמצאת הוא היעיל ביותר) ג

:19שאלה .כתוב אלגוריתם למציאת מספר הצמתים בעץ בינארי כמעט מלא

int FindNumOfNodes( Tree* T) על ). אין לו גישה לאבא( הוא עץ כמעט מלא המיוצג כך שלכל צומת יש גישה רק לבניו Tכאשר

.T - הוא מספר הצמתים בnכאשר , θ( log2(n) )האלגוריתם לרוץ ביעילות : הוא העץTכך למשל אם

.6הפונקציה תחזיר

:20שאלה . עם הרבה כפילויות) תחום המספרים לא ידוע( מספרים ממשיים nיה המקבלת מערך המכיל כתוב פונקצ

)ידוע שבמערך מספר המספרים השונים הוא ))log(nΟ ,על הפונקציה למיין את המערך תוך שימוש ב- ( )))log(log(nn ⋅Οהשוואות .

.כתוב פסאודו קוד עבור הפונקציה הנדרשת

3

2 8

1

- 26 -

:21אלה ש

המערך מתחיל : לבשימו. max < n כאשר A[1..max] במערך n ערמת מקסימום בגודל נתונה .0 מאינדקס ולא 1מאינדקס -ו Left(i) שנסמנם i נוסחאות לחישוב האינדקסים במערך של ילדיו של כתבו, במערך i אינדקס בהינתן

Right(i) ,ההורה של של i שנסמנו Parent(i) סבו של ושל i שנסמנו Grandparent(i)) כלומרGrandparent(i) ההורה של הוא Parent(i) .( זמן חישוב הנוסחאות צריך להיותΘ(1).

Left (i) = __________________________________________

Right (i) = __________________________________________ Parent (i) = _________________________________________ Grandparent (i) = ____________________________________

היה נכנס אליו Aאת המקום במערך ומחזיר xמספר המקבל FindInsertIndex(int x)אלגוריתם תארו

x של פעולת הערמה בסופהInsert(x) האלגוריתם . בצענו אותה לוFindInsertIndex לרוץ בזמן צריך( )log(log( ))nΟ. לוקח 2לשם ביצוע האלגוריתם שחישוב כל חזקה של הניחו Θ(1) גם הסבירו .זמן

.מדוע האלגוריתם שלכם רץ בזמן הנדרש

FindInsertIndex -אלגוריתם ל

- 27 -

ניתוח מבני נתונים

:1שאלה .כל תו מופיע בקובץ בדיוק פעם אחת, תוויםnנתון קובץ המכיל

.י אלגוריתם הפמן"ך הקובץ המקודד אם הקוד המותאם לתווים נוצר עמה אור .2 הוא חזקה של n - הניחו ש:הערה

:2שאלה ,1,2 התוויםn -מצאו שכיחויות ל , nK , כך שיתקבל מהם עץ הפמן בגובהn-1.

. לעלה במסלול הארוך ביותר מהשורשהקשתותגובה של עץ הוא מספר , כזכור: הערה

:3שאלה f:ונתונה פונקצית שכיחויות , Cב "נתונן א C → .

:השלימו את ההגדרה הבאה. א

:הגדרה : הואCב "של הא) prefix code( המייצג קוד פרפיקסי Tמשקל של עץ

:הבאההשלימו את ההגדרה . ב

:הגדרה אם, אופטימאלי ייקרא Cב "של הא) prefix code( המייצג קוד פרפיקסי Tעץ

_________________________________________________________________

1יהיו . ג 2,c cב " שתי אותיות באC ,1הוכיחו שקיים עץ אופטימאלי בו . ששכיחותם מינימאליתc2 - וc .הם אחים ברמה המקסימאלית

:4שאלה :הוכיחו או הפריכו כל אחת מהטענות הבאות

אז )x- לרמה מתחתבכלומר (i+1ברמה y -ו T- בi ברמה xאם . העץ של ערימת מינימוםTיהי ) 1(

yx בהכרח ≤. אין ילד x -לאז לקדקוד בו נמצא הערך העוקב . קדקוד בעץ חיפוש בינארי שיש לו ילד ימני xיהי ) 2(

).בסדר עולה אם נתבונן על סדרת המספרים בעץ x הוא המספר הבא מיד אחרי xהעוקב של (שמאלי . יש הורה משותף או שההורים שלהם אחים2-3ם עוקבים בעץ הערכיעלים שלכל שני )3(

. ילדים2 לפני המחיקה לכל קדקוד יש רק אם ורק אם גורמת לגובה העץ לקטון 2-3מחיקה בעץ )4(

( )B T =

- 28 -

:5שאלה ) עלים יש n עם 2-3בעץ : השלימו )_________Θקודקודים .

:6שאלה .נתון האלגוריתם הבא שאמור למחוק צומת מעץ חיפוש בינארי

.x – בתוכוומצביע לצומת , root –האלגוריתם מקבל מצביע לעץ חיפוש בינארי

delete(node root, node x) 1. if left(x) = NULL and right(x) = NULL 2. if x = root return NULL 3. if x = left( parent(x) ) 4. left(parent(x) ) NULL 5. else 6. right(parent(x) ) NULL 7. return root 8. if left(x) = NULL 9. y successor(x) 10. else 11. y predecessor(x) 12. data(x) data(y) 13. delete(root, y) 14. return root

:הוכיחו או הפריכו את הטענה הבאה. א

. של עץ חיפוש בינאריdeleteם יכול להחליף את פעולת האלגורית :הוכיחו או הפריכו את הטענה הבאה, בין אם הוכחתם ובין אם הפרכתם את סעיף א. ב

.י גובה העץ"יעילות האלגוריתם חסומה ע

:7שאלה נדפיס . )n > 2002, למשל( גדול n -ונניח ש, איברים שונים זה מזהnנתונה ערימת מקסימום הכוללת

:אילו מהטענות הבאות נכונות. preorderאת איברי הערימה בסדר .preorder -איבר המינימום יכול להופיע במקום הראשון בסדר ה )א

1איבר המינימום תמיד יופיע באחד מ )ב2

+⎥⎦⎥

⎢⎣⎢nהמקומות האחרונים בסדר ה - preorder.

⎣איבר המינימום יכול להופיע במקום ה )ג ⎦ 1log +nבסדר ה - preorder. אז איבר המינימום יופיע בדיוק במקום , אם הערימה מלאה לגמרי גם ברמה התחתונה )ד

⎦⎥ -ה⎥

⎢⎣⎢2nבסדר ה - preorder.

!הוכיחו תשובתכם במדויק

- 29 -

:8שאלה רימה בינארית שהיא עץ בדומה לע. רגילהת מקסימום בינארית ערימדומה ל k מדרגה ת מקסימוםערימ

ערימה מדרגה גם , וממומשת במערך) שגם הם מלאים משמאל עד נקודה כלשהי(שלם מלבד אולי העלים k היא עץk- גם .וממומשת במערך) שגם הם מלאים משמאל עד נקודה כלשהי(י שלם מלבד אולי העלים

.כאן כל קדקוד גדול מכל ילדיו . תשובתכםהסבירו? איבריםn שמכילה k מדרגה ת מקסימוםמה הגובה של ערימ )אערימת מקסימום ב ()DeleteMaxהמממש את הפעולה יעיל ככל האפשר תארו אלגוריתם )ב

?k - וnהאלגוריתם כפונקציה של מה יעילות . kמדרגה k לבניית ערימה מדרגה Floyd כיצד ניתן להכליל את האלגוריתם של בקצרההסבירו )ג

.nל בהינתן מערך לא ממוין בגודוהעריכו את היעילות כסכום של טור והציג? k - וnהאלגוריתם כפונקציה של מה יעילות )ד

.את הטור

:9שאלה על )כפי שהוגדרה בכיתה ( FixHeapנניח כי עומד לרשותכם אלגוריתם המסוגל לממש את פעולת

כפי שנלמד (ויד של פלBuildHeapמה יהיה זמן הריצה של אלגוריתם . O(lg(lg n))ערימה בזמן FixHeapתשתמשו בפעולת , הרגילה שלמדנו בכיתהFixHeapאם במקום להשתמש בפעולת , )בכיתה .הוכיחו תשובתכם במדויק? החדשה

:10שאלה כך נקטין את ערכו , איבר מנתוני הערימה, באופן אקראי, נבחר. נתוניםnנתונה ערימת מקסימום המכילה

.FixHeapנבצע ו, שיהיה הנתון הקטן ביותר ? שביצענו FixHeap-מה תוחלת זמן העבודה של פעולת ה

.לשם הפשטות הניחו שהרמה האחרונה בערימה מלאה לחלוטין: הערה

:11 שאלה : איבריםn המכילה Sהאלגוריתם שלהלן ממיין את אברי קבוצה

1נבחר .1 k n< . כלשהו>n בגודל , S1, ..., Sk קבוצות זרות k - לSלק את נח .2

k אם ( כל אחתn אינו מתחלק ).אז הקבוצה האחרונה תכיל פחות אברים, k -במדויק ב

,... ,m1 שתכיל את Mניצור קבוצה נוספת . Si את המקסימום בקבוצה mi -נסמן ב .3mk.

: הבאות אינה ריקה נבצע את הפעולותMכל עוד .4a. נמצא את המקסימום בקבוצהM ,נסמנו ב- Mmax . נוציא אתMmaxמ - M . תהיהSi

.Mmaxהקבוצה שאליה שייך b. נוציא אתMmax מהקבוצה Si . אםSiנמצא ב, עדיין לא התרוקנה- Si מקסימום חדש

.M -ונוסיף אותו ל מהי יעילות זמן ). ממויינותלא (ברשימות מקושרות Mואת הקבוצה , Siנניח שנממש את הקבוצות .א

?k - וnכפונקציה של , הריצה של האלגוריתם ?במימוש זה) nכפונקציה של ( שייתן זמן ריצה אופטימלי k -מהו ה. ב מה יהיה זמן הריצה של האלגוריתם במימוש . בערימות Mואת הקבוצה , Siנניח שנממש את הקבוצות . ג

?זה

- 30 -

:12שאלה מספר nיהיה : היא כדלקמן) Dictionary( של מילון ADTבמימוש מסוים של Insert(x)עלות פעולת

אזי עלות . שנמצאים כעת במבנהx - מספר האיברים הקטנים מsויהיה , האיברים שנמצאים כעת במבנה

Insert(x) היא )1s

n(+

Θ זמן .

? איבריםn למבנה המכיל Insert(x)מה העלות הממוצעת של פעולת

.i שווה לכל x -שקטנים מ, i ≤ n ≥ 0, איבריםiהניחו שההסתברות שיש במבנה בדיוק

:13שאלה :מבצעים את האלגוריתם הבא. מספרים שונים ונתון עץ חיפוש בינארי ריקnנתונה קבוצה של

:האלגוריתם : פעמיםnבצע

. בחר באופן אקראי מספר בקבוצה .1 .הורד אותו מהקבוצה .2 ). ללא איזון( של עץ חיפוש Insertעץ החיפוש בעזרת פונקצית הכנס אותו ל .3

.הסבירו את שיקוליכם. הממוצע במקרהל "מצאו את נוסחת הנסיגה לזמן הריצה של האלגוריתם הנ

. זמןO(1) לוקחים 2 - ו1הניחו שצעדים : הערה

:14שאלה ואין ( איברים בטבלה 5 נניח שיש . ופונקצית ערבול אחידה לטבלה סגורהnנתונה טבלת ערבול בגודל

).DELETEDאיברים המסומנים .pr(i) - ניסיונות בiנסמן את ההסתברות שהכנסת המפתח השישי תיקח בדיוק

.pr(3)את ) כלומר ללא שימוש בנוסחאות(חשבו ישירות . א .תנו נוסחה לתוחלת מספר הניסיונות להכנסת המפתח השישי. ב

:15שאלה מטרת השאלה היא לבחון את תוחלת . איבריםn/2אשר מכילה כבר , m = nערבול בגודל נתונה טבלת

. איבריםn/2מספר הפעולות להוסיף לטבלה הזאת עוד בשני הסעיפים הבאים אתם יכולים להשתמש בנוסחאות שנלמדו בכיתה ליעילות הממוצעת של הפעולות

).'סה וכוהכנ, כגון חיפוש(הבסיסיות המוגדרות על טבלת ערבול איברים לטבלה הזאת בהנחה שהתנגשויות n/2מה תהיה תוחלת מספר הפעולות להוסיף )א

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

איברים לטבלה הזאת בהנחה שהתנגשויות n/2מה תהיה תוחלת מספר הפעולות להוסיף )ב-Reבחלק מהכיתות שיטה זו נקראה ( טבלה סגורה – Open Addressingנפתרות על ידי

Hashing( ,הוכיחו תשובתכם? ובהנחה שפונקצית הערבול שבה משתמשים היא אחידה.

- 31 -

:16שאלה מוסיפים לו את השיפור . של קבוצות זרות הממומש בעזרת רשימות משורשרותADTנתון . Union by Sizeשל . זמן במקרה הגרועO(n log n) ייקחו unionפעולות (n-1) -שהוכיחו . א) ייקחו union פעולות (n-1) -שהוכיחו . ב log( ))n nΩ . זמן במקרה הגרוע⋅

:17שאלה " רשימות משורשרות"ומבנה הנתונים " קבוצות זרות "המופשטטיפוס הנתונים ב תשאלה זו עוסק

.Union by Size השיפור שלעםכפי שנלמד בכיתה במערךהממומשות

. MakeSet פעולות nשמתוכן יש Union, Find, MakeSet פעולות mמבצעים סדרה של )()( תקיים ה Union(x,y) בוצעש כל פעםנניח ש. k≤1יהיה ysizekxsize ⋅≥

. בהתאמהx,y הם גודל הקבוצות של size(y) - וsize(x)כאשר הוכיחו ?m, n, kכפונקציה של הפעולות mשל כל זמן הריצה הכולל סם עליון הדוק ככל האפשר לתנו ח

.תשובתכם

:18שאלה י יער " עn,...,1,2קבוצות זרות שאיבריהן לקוחים מהתחום המופשט של נתונים הטיפוס מממשים את

. Path-compression -ו Union By Size: של עצים עם שני השיפורים : פעולותn+mמבצעים סדרה של

. האפשריותMake-Set - פעולות הnכל , תחילה •, Union רק פעולות ברצףכאשר ראשית מבוצעות , Find - וUnion פעולות של m, אחריהן •

.Find רק פעולות ברצףמבוצעות , בשאר הפעולות, ואחריהן)תיקח ) באופן שתוארה לעיל (Find - וUnion - פעולות הmהוכיחו שסדרת )mΘ.

:19שאלה פעולת , Path Compression - וUnion-By-Sizeבמימוש קבוצות זרות בעזרת יער של עצים עם ) 1

findתיקח במקרה הגרוע : Θ(1) )א Θ(n) )ב Θ(log n) )ג . היא ההפוכה לפונקצית אקרמןα(n)כאשר , Θ(α(n)) )ד

,1 של המספרים במימוש קבוצות זרות) 2 2, , log( )nK בעזרת רשימות מקושרת עם

Union-By-Size , פעולתUnionתיקח במקרה הגרוע : .Θ(1) )ה .Θ(log(log(n))) )ו .Θ(log(n)) )ז .Θ(nlog(n)) )ח . אף אחת מהתשובות אינה נכונה )ט

- 32 -

מציאת מבני נתונים

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

• MakeSet(x) - יצירת קבוצה בעלת איבר אחד – x . יעילות נדרשתθ(1)בממוצע .

• Union(A,B) - המקבלת שתי קבוצות Aו - B ,יעילות . ומחזירה את קבוצת האיחוד שלהן ). בהתאמהB - ובA - הם מספר האיברים ב|B| - ו|A|( בממוצע θ(|A|+|B|)נדרשת

• Intersect(A,B) - המקבלת שתי קבוצות Aו - B ,יעילות . ומחזירה את קבוצת החיתוך שלהן

). בהתאמהB - ובA - הם מספר האיברים ב|B| - ו|A|( בממוצע θ(|A|+|B|)נדרשת

• Query(A,x) – המחזירה trueם " אםA∋x . יעילות נדרשתθ(1)בממוצע .

:2שאלה :בפעולות הבאותהתומך , לשמירת מספרים טבעייםADTנתון

• MakeEmpty( ) –פעולה זו מאתחלת מבנה ריק .

• IsEmpty( ) – פעולה זו מחזירה trueם המבנה ריק" אם.

• Insert(x) – פעולה זו מכניסה את המספר xלמבנה . )על פעולה זו להתבצע ביעילות )log( )nΘכאשר , במקרה הגרועn הוא מספר המספרים במבנה .

• Delete(x) – x פעולה זו מוציאה את המספר . הנמצא במבנה הינו נתוןxמהמבנה .

)על פעולה זו להתבצע ביעילות )log( )nΘכאשר , במקרה הגרועnהוא מספר המספרים במבנה .

• InsertFixed(x) –ה את המספר פעולה זו מכניסxהוותיק ומוציאה מהמבנה את הנתון , למבנה . כך שאחרי הפעולה מספר הנתונים במבנה הוא כפי שהיה לפני הפעולה, ביותר

)על פעולה זו להתבצע ביעילות )log( )nΘכאשר , במקרה הגרועnהוא מספר המספרים במבנה . .להניח שפעולה זו לא תופעל כאשר במבנה אין נתונים כללניתן : הערה

.ופרטו איך תתבצע כל אחת מהפעולות. ל" הנADT -הציעו מבנה נתונים למימוש ה

. נתוניםN -הניחו כי בכל רגע נתון לא יהיו במבנה הנתונים יותר מ: הערה

- 33 -

:3שאלה 1: של מספריםסופיתסדרה לניהול ADTנתון 2 3, , , , na a a aK.ה - ADTתומך בפעולות הבאות :

• MakeNew( ) –על פעולה זו להתבצע ב. מבנה ריקייצרת פעולה זו מ-( )1Θבמקרה הגרוע .

• IsEmpty( ) – פעולה זו מחזירה trueעל פעולה זו להתבצע ב. ם המבנה ריק" אם-( )1Θ במקרה .הגרוע

• Insert(i, data) – פעולה זו מכניסה את הנתון dataלמקום ה - iאם נסמן ב. סדרה ב- n את אורך

:אזי, ברגע ביצוע הפעולה, הסדרה .(n+1) - ל1 הוא מספר טבעי בין i .א יזוזו , i, (i+1), (i+2), …, n: כל אחד מהנתונים שהיו במקומות .ב

.בהתאמה (n+1) ,… ,(i+3) ,(i+2) ,(i+1): למקומות . יישארו במקום שהיו(i-1) ,… ,2 ,1: הנתונים שהיו במקומות

)על פעולה זו להתבצע ביעילות .ג )log( )nΘבמקרה הגרוע .

• Delete( i ) –את הנתון הסדרה פעולה זו מוחקת מה - i .אם נסמן ב- n ברגע , אורך הסדרה את :אזי, ביצוע הפעולה

.n - ל1 הוא מספר טבעי בין i .א יזוזו , n ,… ,(i+2) ,(i+1): כל אחד מהנתונים שהיו במקומות .ב

. בהתאמה i, (i+1), (i+2), …, (n-1): למקומות .שארו במקום שהיו יי(i-1) ,… ,2 ,1: הנתונים שהיו במקומות

)על פעולה זו להתבצע ביעילות .ג )log( )nΘבמקרה הגרוע . .זואין צורך לממש פעולה : הערה

• Get( i ) –פעולה זו מחזירה את הנתון ה - iסדרה אך אינה מוחקת אותו מהסדרה ב.

)על פעולה זו להתבצע ביעילות )log( )nΘכאשר , במקרה הגרועn אורך הסדרה הוא .

:רצף הפעולות הבא, למשל

MakeNew( ) Insert(1, 1.5) Insert(1, 2.5) Get(1) // 2.5 פעולה זו מחזירה Inser(2, 3.5) Delete(1) // 2.5 את הנתון סדרהפעולה זו מוחקת מה Get(2) // 1.5פעולה זו מחזירה

.ופרטו איך תתבצע כל אחת מהפעולות. ל" הנADT -הציעו מבנה נתונים למימוש ה

- 34 -

:4שאלה כאשר כל שיר מאופיין בזמר המבצע אותו ובמספר טבעי , )מת שיריםרשי (Play List לניהול ADTנתון

. המייצג את דירוג השיר : תומך בפעולות הבאותADT -ה• MakeEmpty( ) –על פעולה זו להתבצע ב. פעולה זו מאתחלת מבנה ריק-( )1Θבמקרה הגרוע .

• IsEmpty( ) – פעולה זו מחזירה trueעל פעולה זו להתבצע ב. נה ריקם המב" אם-( )1Θ במקרה

.הגרוע

• InsertSong(PreformerName, SongRating, FilePath) – פעולה זו מכניסה למבנה את . FilePathהנמצא במחשב במסלול , SongRatingבעל דירוג , PreformerNameהשיר של הזמר

)על פעולה זו להתבצע ביעילות )log( )nΘכאשר , במקרה הגרועnהוא מספר השירים במבנה .

• PlayNext( ) –הפעולה מחזירה . פעולה זו גורמת לניגון השיר הבאtrueם קיים שיר נוסף " אם :י הלוגיקה הבאה"השיר הבא שינוגן יקבע עפ. לנגןינוגן השיר בעל הדירוג הגבוה ביותר של , PlayNext אם זו ההפעלה הראשונה של הפעולה

.הזמר שנכנס ראשון למבנה את הזמר של השיר האחרון P -נסמן ב, PlayNextשל הפעולה אם זו אינה ההפעלה הראשונה

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

)על פעולה זו להתבצע ביעילות )log( )nΘכאשר , במקרה הגרועnהוא מספר השירים במבנה .

:רצף הפעולות הבא, למשלMakeEmpty( ) InsertSong ("23 ,"הראל סקעת, "C:\My Music\שלכת.mp3") InsertSong("18 ,"הראל סקעת, "C:\My Music\הנני כאן.mp3") InsertSong ("16 ,"הראל מויאל, "C:\My Music\נר על החלון.mp3") InsertSong ("19 ,"הראל מויאל, "C:\My Music\משאלה.mp3") InsertSong ("12 ,"שירלי לילו, "C:\My Music\לך איתה.mp3") PlayNext( ); PlayNext( ); PlayNext( ); PlayNext( ); InsertSong("20 ,"לירון לב, "C:\My Music\נבראתי לך.mp3") PlayNext( ); PlayNext( );

):מימין לשמאל(יגרום לניגון השירים לפי הסדר הבא ; לך איתה–שירלי לילו ; משאלה-הראל מויאל ; שלכת–הראל סקעת ; נבראתי לך–לירון לב ; נר על החלון–הראל מויאל ; הנני כאן–הראל סקעת

.ך תתבצע כל אחת מהפעולותופרטו אי. ל" הנADT -הציעו מבנה נתונים למימוש ה

הגורמת לניגון השיר שנמצא , Play(FilePath)לצורך המימוש ניתן להניח שקיימת הפונקציה : הערה .FilePathבמסלול

- 35 -

:5שאלה ,1מתוך תחום נתון כשכל קבוצה כוללת מספרים מבנה נתונים עבור קבוצות זרות עליכם לתכנן , nK .

, כפי שתוארו בכיתהFind(x) ו MakeSet(x) , Union(x,y)פעולות ריך לתמוך בצ הנתונים-מבנה-אי( ומתוך מבנה הנתונים בכלל מתוך הקבוצה בה הוא נמצאx את המורידה, Delete(x)גם בפעולה ו

צריכה להתבצע רק אם Delete(x)הפעולה . )MakeSet(x)אפשר יהיה לבצע שוב בהמשך את הפעולה xאחרת יש להחזיר הודעה ש(קבוצה אינו נציג ה x-הוא הנציג של קבוצתו ואין למוחקו .(

:ותארו בקצרה כל אחת מהפעולות כך שיתקייםנתונים המבנה את תארו )log( כולל שלקח זמןי פעולות תmכל סדרה של nnmO +.

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

).שוב אם ההוכחה דומה למה שראינו בכיתה תארו רק את השינויים בהוכחה( פעולות mשל

:6שאלה :תמוך בפעולות הבאות מספרים ממשיים ומאפשר לN לכל היותר המאפשר לשמורנים והציעו מבנה נת

Find(x): מחזירה true אם xנמצא במבנה ,falseאחרת . :Delete(x) מוחקת את xמהמבנה . Insert(x): מוסיפה את xכאשר אם המבנה מכיל כבר , למבנהNאיברים אז כדי לפנות מקום ל - x יש

אם יש מספר . שבוצעו עליו הוא הגדול ביותרFind -ולות הלהוציא מהמבנה את האיבר שמספר פע ).לא חשוב את מי( יש להוציא אחד מהם Findאיברים שבוצעו עליהם אותו מספר מקסימלי של פעולות

הוא מספר האיברים שנמצאים במבנה nכאשר , במקרה הגרועO(log n) כל פעולה צריכה להיותיעילות

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

:7שאלה ). n,...,1,2 -לאו דוקא מ(מספרים כלשהם על קבוצות זרות המכילות תומך בפעולות הבא ADT -ה

.nהניחו שמספר המספרים במבנה אינו עולה על • MakeSet(x) – מקבלת מספרxצרת קבוצה חדשה המכילה את המספר ויוxבלבד .

. הוא נציג הקבוצהxהמספר • Find(x) – מקבלת מספר xומחזירה את הנציג של הקבוצה ש - xשייך אליה . • Union(repx, repy) – מקבלת מספריםrepxו - repy שהם נציגים של שתי

ה אחד נציג הקבוצה החדשה יהי. קבוצות ומאחדת את שתי הקבוצות לקבוצה אחת .מאבריה

במקרה O(log n)היא ) MakeSetכולל (הנדרשת של כל אחת משלוש הפעולות יעילות ה .הגרוע

ונתחו , כתבו לכל אחת מהפעולות אלגוריתם, ל" הנADT -למימוש ה תארו מבנה נתונים )א

.את היעילות של כל פעולה במקרה הגרועאם נאפשר ) ופשוט יותר(ה סטטי הסבירו בקיצור כיצד ניתן להפוך את מבנה הנתונים למבנ )ב

-שתי הפעולות האחרות צריכות עדיין להתבצע ב. O(n) - להתבצע בMakeSetלפעולת O(log n) . הפעולות במבנה הנתונים החדש3יש לכלול בהסבר איך יתבצעו .

- 36 -

:8שאלה חברה יש הניחו שלכל . התומך בפעולות של ספק סלולרי הנותן שרותים לחברות מסחריותADTנגדיר

. טלפונים סלולרים ברשותהkלכל היותר הוא חשבון טלפון bill, )מטיפוס מחרוזת( מייצג שם של חברה CompanyNameבהגדרות שלהלן

חשבונות טלפון r הוא מערך של BillArray -ו, הוא מספר הטלפונים בחברהint( ,rמטיפוס (אחרון . אחרונים

הנדרשות הפעולות

• AddNewPhone (CompanyName, bill) מוסיפה על שם החברה טלפון נוסף .billשחשבונו האחרון הוא

)log)על פעולה זו להתבצע ביעילות ) log( ))O n r+ , כאשרn הוא מספר החברות . הוא מספר הטלפונים שברשות החברהr -ו, המסחריות המשתתפות במסלול המיוחד

• NewMonthlyBills (CompanyName, r, BillArray) – מקבלת ב-

CompanyName) ב, שם של חברה) מטיפוס מחרוזת- r את מספר הטלפונים את החשבונות האחרונים BillArray המקומות הראשונים של המערך r -וב, בחברה

. הטלפונים שברשות החברהrשל מעדכנת את החשבונות החודשיים של החברה NewMonthlyBillsהפעולה

. אם החברה אינה קיימת עדיין יש להוסיף אותה למסלול המיוחד.לחשבונות חדשים)log)על פעולה זו להתבצע ביעילות ) )O n r+ , כאשרn הוא מספר החברות

.המסחריות המשתתפות במסלול המיוחד

• ApplyDiscount(CompanyName) -מקבלת ב -CompanyName) מטיפוסומשנה את החשבונות האחרונים של , לול המיוחדשם של חברה השייכת למס) מחרוזת

:החברה באופן הבא לחשבון הגבוה ביותר מבין חשבונות הטלפונים שברשות החברה תינתן הנחה

.20%ולחשבון השני בגובהו תינתן הנחה של , 30%של )log)על פעולה זו להתבצע ביעילות ) log( ))O n r+ , כאשרn הוא מספר החברות

. הוא מספר הטלפונים שברשות החברהr -ו, ריות המשתתפות במסלול המיוחדהמסח .פעולה זו יכולה להתבצע עבור כל חברה מספר פעמים בכל חודש: הערה

ונתחו את היעילות של , כתבו לכל אחת מהפעולות אלגוריתם, ל" הנADT -למימוש ה תארו מבנה נתונים

.כל פעולה במקרה הגרוע

- 37 -

:9שאלה :התומך בפעולות הבאות, לשמירת מספריםADT נתון• MakeEmpty( ) –פעולה זו מאתחלת מבנה ריק . • IsEmpty( ) – פעולה זו מחזירה trueם המבנה ריק" אם. • Insert(x) – פעולה זו מכניסה את המספר xעל פעולה זו להתבצע ביעילות . למבנה( )log( )nΘ

. הוא מספר המספרים במבנהnכאשר , במקרה הגרוע• Delete(x) – x פעולה זו מוציאה את המספר . הנמצא במבנה הינו נתוןxעל פעולה זו . מהמבנה

)להתבצע ביעילות )log( )nΘכאשר , במקרה הגרועnהוא מספר המספרים במבנה . • Find(x) –חזיר מtrueם " אםx(1)על פעולה זו להתבצע ביעילות. נמצא במבנהΘבממוצע . • OrderedSuccessor(x) – x מבין הנתונים שבמבנה, פעולה זו מחזירה. הנמצא במבנה הינו נתון ,

Θ(1)על פעולה זו להתבצע ביעילות). הנתון הבא בגודלו (x -את הנתון המינימאלי הגדול מ .בממוצע . אינו הנתון המקסימאלי במבנהx -ניתן להניח ש: הערה

• InsertionSuccessor(x) – x מבין הנתונים שבמבנה, פעולה זו מחזירה. הנמצא במבנה הינו נתון ,על פעולה זו להתבצע ). הנתון הבא לפי סדר ההכנסה (xאת הנתון שנכנס ראשון אחרי

. בממוצעΘ(1)ביעילות . אינו הנתון שנכנס אחרוןx, מבין הנתונים שבמבנה ניתן להניח ש: הערה

.ופרטו איך תתבצע כל אחת מהפעולות. ל" הנADT -הציעו מבנה נתונים למימוש ה

. נתוניםN -הניחו כי בכל רגע נתון לא יהיו במבנה הנתונים יותר מ: הערה

:10שאלה . הבא לתור עדיפויות עם כפילויות של עדיפויותADT - הנגדיר את

:הפעולות בהן יש לתמוך• Insert( priority, data ) – מכניסה את הנתון data בעדיפות priorityלתוך המבנה .

)log)על פעולה זו לרוץ ביעילות ))O nכאשר , במקרה הגרועn הוא מספר הנתונים במבנה ברגע .וע הפעולהביצ

• DeleteMin( ) –אם יש יותר מנתון אחד . מוציאה מהמבנה את הנתון עם העדיפות הקטנה ביותר

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

)log) על פעולה זו לרוץ ביעילות ))O nכאשר , במקרה הגרועn הוא מספר הנתונים במבנה ברגע .ביצוע הפעולה

• Min( ) -אם יש יותר מנתון אחד מאותה עדיפות . מחזירה את הנתון עם העדיפות הקטנה ביותר

.למבנההפעולה תחזיר מבין כל הנתונים עם העדיפות המינימלית את הנתון שנכנס ראשון , מינימלית . במקרה הגרועΘ(1)על פעולה זו לרוץ ביעילות

• Build(PriArr[ ], DataArr[ ], n) – מייצרת תור עדיפויות משני המערכים בהתאמה

iכך שאם , )PriArr[i]היא , DataArr[i]העדיפות של הנתון ( j<ו - Pr [ ] Pr [ ]iArr i iArr j= , .j - יצא מהבנה לפני הנתון הi -אז הנתון ה

)על פעולה זו לרוץ ביעילות )nΘ , כאשרnהוא גודל שני המערכים .

ונתחו את , כתבו לכל אחת מהפעולות אלגוריתם, תארו במדויק את מבנה הנתונים בו בחרתם להשתמש .היעילות של כל פעולה

- 38 -

:11שאלה נתונים הטיפוס עבור Union By Sizeי יער של עצים עם השיפור של " נתייחס למימוש עבשאלה זו . n,...,1,2לייצוג קבוצות זרות שאיבריהן לקוחים מהתחום המופשט

לבצע את המבנה יאפשר Find - וMakeSet ,Unionברצוננו לשנות את המימוש כך שבנוסף לפעולות

:הפעולות הבאותAvgPath(x) – בהינתןx , פעולה זו תחשב ותחזיר את ממוצע , )שהוא גם שורש העץ(נציג של קבוצה

. אל הצמתים בעץx -המרחקים מ ואת אברי הקבוצה nx - בxאם נסמן את מספר האיברים בקבוצה של , כלומר ∑ צריך להחזיר את AvgPath (x)אז , Set(x) - בxשל

∈ )x(SetyT

x

)y(dn1

.המייצג את הקבוצה, T בעץ y הוא העומק של dT(y)כאשר

PrintSet(x) - בהינתן x , פעולה זו תדפיס את אברי הקבוצה, )שהוא גם שורש העץ(נציג של קבוצה .xשל :דרישות יעילות

. זמןMakeSet(x) :O(1)פעולת . זמןUnion(x, y) :O(1)פעולת .x הוא מספר האברים בקבוצה של nxכאשר , זמןFind(x) :O(log(nx))פעולת . זמןAvgPath(x) :O(1)פעולת .x הוא מספר האברים בקבוצה של nxכאשר , זמןPrintSet(x) :O(nx)פעולת

:12שאלה : הבאADT -נתון ה

• MakeEmpty( ) –פעולה זו מייצרת מבנה ריק . • IsEmpty( ) – מחזירה trueם המבנה ריק" אם. • Insert( x ) – פעולה זו מכניסה את המספר xעל פעולה זו לרוץ ביעילות. למבנה))n(log(Ο ,

. הוא מספר הנתונים במבנהnכאשר • Delete( x ) – פעולה זו מוציאה את המספר xפעולה זו לרוץ ביעילותעל . מהמבנה))n(log(Ο ,

הוא מספר הנתונים במבנהnכאשר • MinDifference( x ) – פעולה זו מחזירה את הערך המוחלט של ההפרש בין x לבין הנתון במבנה

הוא מספר הנתוניםnכאשר , n(log(Ο((על פעולה זו לרוץ ביעילות. x -הקרוב ביותר בערכו ל .במבנה, אינו נמצא במבנהxאך אם . 0אזי ההפרש המבוקש הוא , נמצא במבנהxשימו לב שאם : הערה

.0 -ל גדול מ"ההפרש הנ

.ל" הנADT -הציעו מבנה נתונים המממש את ה. א : שתואר בתחילת השאלה גם את הפעולהADT -נניח שברצוננו להוסיף ל. ב• MinAllDifferences( ) –רה את הערך המוחלט של ההפרש בין שני המספרים פעולה זו מחזי

.Ο)1(על פעולה זו לרוץ ביעילות. במבנה הקרובים ביותר זה לזה בערכםאך אם כל . 0אזי ההפרש המבוקש הוא , שימו לב שאם ישנם במבנה שני איברים שווים: הערה

.0 -ל גדול מ"ההפרש הנ, האיברים שונים זה מזה .עו מבנה נתונים התומך בכל הדרישות הצי

- 39 -

:13שאלה על הפעולות ). מופיעות להלן(הציעו מבנה נתונים שיתמוך בפעולות הרגילות על תור עדיפויות מקסימום

.לפעול ביעילות המצוינת • MakeEmpty( ) :במקרה הגרוע זמן הΘ(1). • IsEmpty( ) :במקרה הגרוע זמן הΘ(1). • Insert(x) :הגרוע במקרהזמן ה Θ(1). שימו לב לזמן הנדרש בפעולה זו. • Max( ) :במקרה הגרוע זמן הΘ(1). • DeleteMax( ) :במקרה הגרוע זמן הO(n log n) כאשר n הוא מספר הנתונים העכשווי

.במבנה Θ(m הוא במקרה הגרוע Insert הם kשמתוכם ) מכל הסוגים( פעולות m - הזמן ל:והחשוב ביותר

+ k log k).

אך בהחלט ייתכן שתידרשו לשנות , בנה הנתונים להתבסס על אחד או יותר ממבני הנתונים שלמדנועל מ .או להוסיף מבנים משלכם/ו

:14שאלה הרגילות המגדירות Insert, DeleteMin, Min ותומך בפעולות BEAPנגדיר מבנה נתונים חדש שנקרא

. שמחפשת האם נתון מסוים נמצא במבנהFind אולם מסוגל לתמוך גם בפעולה, תור קדימויות מינימום .HEAP מכיוון שהוא מעין ואריאציה על הערימה BEAPהמבנה נקרא

BEAP -ה. ואפשר להניח שהם כולם שונים זה מזה, הם מספרים שלמים BEAP -הנתונים שיהיו ב

החשובה כך שתתקיים התכונה, )מימדי-נשתמש רק בחציו של מערך דו(יישמר במטריצה משולשית .המספרים ממוינים בסדר עולה, לאורך כל שורה או עמודה במטריצה: הבאה, כפי שאפשר לראות בדוגמה הבאה, לאורך האלכסונים של המערךBEAP -המספרים יתווספו ל, כן-כמו

.וכפי שיוסבר בצורה יותר מדויקת בהמשך

ש הוא אמור להתווסף למשבצת אם נוסיף כעת איבר חד. מספריםn = 11 שמכיל BEAP הנה :דוגמהוכך הלאה עד , 3 ובעמודה 3האיבר שיתווסף אחריו ייכנס למשבצת בשורה . 2 ובעמודה 4בשורה

כמובן (1 ובעמודה 6ואז נתחיל להוסיף איברים לאלכסון החדש שמתחיל בשורה , שיתמלא האלכסון הזהתתקיים התכונה שכל שורה כך ש, לאחר הוספתו של כל איבר חדשBEAP - את הלתקןשיש לדאוג

כי BEAP -המשבצות המושחרות יישארו ריקות במהלך כל חייו של ה). ועמודה ממוינת בסדר עולה .מימדי משולשי-אנחנו משתמשים רק במערך דו

6 5 4 3 2 1

13 9 4 1 1

20 5 2 2

8 6 3

21 4

23 5

6

, של המערךi -נגדיר מהו האלכסון ה, ליאו ייכנס האיבר הבא באופן פורמכדי להגדיר את המקום שאלי .max⋅maxכאשר מדובר במערך מגודל , i ≤ max ≥ 1וזאת עבור

. (1,i) ,… ,(i−2,3) ,(i−1, 2) ,(i,1) כולל את המשבצות i -האלכסון ה, אם כן

- 40 -

ריק 6אלכסון . כיל רק איבר אחד מ5ואילו אלכסון , 1,2,3,4כך למשל בדוגמה מלאים האלכסונים מספר .לגמרי

אם כעת נרצה להכניס איבר הוא אמור להיכנס למשבצת הראשונה שפנויה באלכסון הראשון שיש בו והמשבצת הראשונה , 5 -האלכסון הראשון שאינו מלא הוא האלכסון ה, בדוגמה כאמור. עדיין מקום

. כפי שכבר נאמר(4,2)שפנויה בו היא משבצת

וכן שיש שתי פונקציות , כרגעBEAP - שנמצא בnבכל שלב אתם יודעים מהו מספר הנתונים שהניחוint Row(int n)ו - int Col(int n) שמחזירות את מספר השורה ומספר העמודה שאליהם יש להוסיף

.אתם יכולים להשתמש בפונקציות האלה כבקופסאות שחורות. איבר חדש הנוכחי BEAP - ב12 - כי את האיבר הRow(11) = 4 ,Col(11) = 2: למעלה מתקייםBEAP -ב, למשל

.2 ובעמודה 4 איברים עלינו להוסיף למשבצת בשורה n = 11שמכיל

: כתבו אלגוריתמים עבור הפעולות הבאות• int Min(): מבלי להוריד אותו מהמבנה( מחזירה את המנינימום .(

.Θ(1) יעילות הפעולה צריכה להיות • void Insert(int x): מוסיפה נתון חדש xל - BEAP ,ומתקנת כמובן את ה- BEAP .

) יעילות הפעולה צריכה להיות )O n כאשר nהוא מספר הנתונים ב - BEAPכרגע .

. לא תעשה דברInsertאז פעולת , אם אין במבנה מקום• int Find(int x): אם 1 מחזירה xגע ב נמצא כר- BEAP , אחרת0ומחזירה .

) יעילות הפעולה צריכה להיות )O n כאשר nהוא מספר הנתונים ב - BEAPכרגע .

. התחילו את החיפוש בנתון הימני העליון במטריצה: רמז• int Select50(): נתונים בגודלו מבין ה50 -את האיבר ה) מבלי להוריד מהמבנה( מחזירה

. 50 הוא לפחות BEAP -הנתונים ב' הניחו שמס. BEAP - שנמצאים כרגע ב . כתבו עבור פעולה זו אלגוריתם יעיל ככל האפשר בסדר גודל

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