1. ADTs: Array, Queue, Stack, Linked List
תרגול 4
ADTs: Array, Queue, Stack, Linked List

2. ADT – מבנה נתונים אבסטרקטי
דוגמאות:

3. ADT – מבנה נתונים אבסטרקטי
דוגמאות:

4. ADT – מבנה נתונים אבסטרקטי
דוגמאות:
הערה חשובה: מבני גישה אבסטרקטיים ניתן לממש בכמה דרכים שונות.

5. שאלה 1 S קבוצה עם לכל היותר n איברים (n נתון).
מצאו מבנה נתונים בגודל O(n) התומך בפעולות הבאות בזמנים הנתונים:

6. שאלה 1 פתרון: בעזרת מיון ישיר (מערך) . . . Init (n)
Null
. . .
COUNT = 0
Init (n)
for (i=0 ; i<n ; i++)
A[i] = null;
count = 0;

7. שאלה 1 X פתרון: בעזרת מיון ישיר (מערך) . . . isElement (k)
COUNT = 0
COUNT = 1
. . .
isElement (k)
return (A[k] != null);
Null X
Key= k
k-1
Null k
Null
k+1
Insert (x)
If(!isElement (x.key)){
A[x.key] = x;
count++; }
Null
Null
Null
. . .

8. שאלה 1 פתרון: בעזרת מיון ישיר (מערך) Remove (k) If(isElement (k)){
isEmpty ()
return (count == 0);
Remove (k)
If(isElement (k)){
A[k] = null;
count--; }
hasAll ()
return (count == n);

9. שאלה 2
שאלה: הציעו כיצד לממש תור בעזרת 2 מחסניות. פתרון: x a b c d

10. שאלה 2 שאלה: הציעו כיצד לממש תור בעזרת 2 מחסניות. פתרון: Enqueue (x)
moveElements(A,B);
A.Push(x);
moveElements(B,A);
Dequeue ( )
element = A.Pop();
return element;
isEmpty ( )
return A.isEmpty();
moveElements(X,Y)
while (! X.isEmpty()) {
temp = X.Pop();
Y.Push(temp) ; }

11. שאלה 2 שאלה: הציעו כיצד לממש תור בעזרת 2 מחסניות. פתרון נוסף:
שאלה: הציעו כיצד לממש תור בעזרת 2 מחסניות. פתרון נוסף:
Enqueue (x)
A.Push(x);
Dequeue ( )
moveElements(A,B);
element = B.Pop();
moveElements(B,A);
return element;
isEmpty ( )
return A.isEmpty();
moveElements(X,Y)
while (! X.isEmpty()) {
temp = X.Pop();
Y.Push(temp) ; }

12. שאלה 2 שאלה: הציעו כיצד לממש תור בעזרת 2 מחסניות. פתרון נוסף נוסף:
שאלה: הציעו כיצד לממש תור בעזרת 2 מחסניות. פתרון נוסף נוסף:
Enqueue (x)
A.Push(x);
Dequeue ( )
If (B.isEmpty())
moveElements(A,B);
element = B.Pop();
return element;
isEmpty ( )
return ( A.isEmpty()
&& B.isEmpty());
moveElements(X,Y)
while (! X.isEmpty()) {
temp = X.Pop();
Y.Push(temp) ; }

13. שאלה 3
שאלה: נתונות 2 רשימות מקושרות חד-כיווניות L1,L2 עם זנב משותף באורך k, ורישות לא משותפות באורכים n וm. הראו כיצד ניתן למצוא את הקודקוד המשותף הראשון בזמן O(m+n+k). דוגמא:
m = 4
k = 3
Null
Head 2
n = 2
Head 1

14. שאלה 3
שאלה: נתונות 2 רשימות מקושרות חד-כיווניות L1,L2 עם זנב משותף באורך k, ורישות לא משותפות באורכים n וm.
הראו כיצד ניתן למצוא את הקודקוד המשותף הראשון בזמן O(m+n+k).
פתרון:
מוצאים את האורך של L1,L2
ברשימה הארוכה, זזים קדימה את ההפרש
כעת המרחק מהקודקוד המשותף שווה ב2 הרשימות. כל עוד הרשימות לא התאחדו (קודקוד ראשון משותף), זזים קודקוד 1 קדימה בשתי הרשימות.

15. שאלה 3 הדגמת הפתרון: פתרון: מוצאים את האורך של L1,L2
ברשימה הארוכה, זזים קדימה את ההפרש
כעת המרחק מהקודקוד המשותף שווה ב2 הרשימות. כל עוד הרשימות לא התאחדו (קודקוד ראשון משותף), זזים קודקוד 1 קדימה בשתי הרשימות.
הדגמת הפתרון:
m = 4
k = 3
Null
Head 2
n = 2
Head 1

16. שאלה 3 הדגמת הפתרון: פתרון: מוצאים את האורך של L1,L2
ברשימה הארוכה, זזים קדימה את ההפרש
כעת המרחק מהקודקוד המשותף שווה ב2 הרשימות. כל עוד הרשימות לא התאחדו (קודקוד ראשון משותף), זזים קודקוד 1 קדימה בשתי הרשימות.
הדגמת הפתרון:
Current
Current
Current
Current
Current
Current
Current
Current
Null
Current
Head 2
Current
Current
Current
Current
Current
Head 1
Length1 = 7
Length2 = 5

17. שאלה 3 הדגמת הפתרון: פתרון: מוצאים את האורך של L1,L2
ברשימה הארוכה, זזים קדימה את ההפרש
כעת המרחק מהקודקוד המשותף שווה ב2 הרשימות. כל עוד הרשימות לא התאחדו (קודקוד ראשון משותף), זזים קודקוד 1 קדימה בשתי הרשימות.
הדגמת הפתרון:
Current 1
Current 1
Current 1
Null
Head 2
Current 2
Head 1
Length1 – Length2 = 2

18. שאלה 3 הדגמת הפתרון: פתרון: מוצאים את האורך של L1,L2
ברשימה הארוכה, זזים קדימה את ההפרש
כעת המרחק מהקודקוד המשותף שווה ב2 הרשימות. כל עוד הרשימות לא התאחדו (קודקוד ראשון משותף), זזים קודקוד 1 קדימה בשתי הרשימות.
הדגמת הפתרון:
Current 1
Current 1
Current 1
Null
Head 2
Current 2
Current 2
Current 2
Head 1

19. שאלה 4
שאלה: בהינתן רשימה חד-כיוונית, הציעו דרך בה כל מעבר לחוליה הבאה או הקודמת יהיה בזמן O(1), ע"י תוספת זכרון של O(1) בלבד
פתרון:
אי-אפשר להפוך את הרשימה לדו-כיוונית - זה O(n) זיכרון
נשתמש ב2 מצביעים – current וprev שיצביעו על האיבר הנוכחי וזה שבא לפניו
כשנזוז קדימה ברשימה, נפנה ברשימה את המצביעים אחורה
כשנזוז אחורה ברשימה, נחזיר את המצביעים קדימה

20. שאלה 4 - הדגמה moveBackward() temp=current; current=prev;
שאלה 4 - הדגמה
moveBackward()
temp=current;
current=prev;
prev=prev.next;
current.next=temp;
init()
current=head;
prev=null;
moveForward()
temp = prev;
prev=current;
curent=current.next;
prev.next=temp;
temp = prev;
prev=current;
curent=current.next;
prev.next=temp;
prev
current
Temp
Head

21. איחוד 3+4 (אם יש זמן)
שאלה: נתונות 2 רשימות מקושרות חד-כיווניות עם זנב משותף באורך k, ורישות לא משותפות באורכים n וm. הציעו דרך למצוא את הקודקוד המשותף הראשון של 2 הרשימות, בזמן שאינו תלוי בk. ( הניחו m,n>0 וכן k>>m,n ) מה הזמן והמקום שדורש הפתרון שהצעתם דורש?

22. שאלה 5
שאלה: A מטריצה בוליאנית (ערכי 0 או 1) בגודל nXn. תארו מבנה נתונים שתומך בפעולות הבאות בזמנים הנתונים:

23. שאלה 5
פתרון:
נשמור, בנוסף למטריצה, גם מערך Sum, שמכיל את סכום האיברים בשורות. כלומר, Sum[i] = מספר האחדות בשורה ה-i.
בנוסף, נשמור 2 מונים של מספר השורות המלאות ומספר השורות ללא אחדות כלל.

24. שאלה 5
פתרון:
נשמור, בנוסף למטריצה, גם מערך Sum, שמכיל את סכום האיברים בשורות. כלומר, Sum[i] = מספר האחדות בשורה ה-i.
בנוסף, נשמור 2 מונים של מספר השורות המלאות ומספר השורות ללא אחדות כלל.
הדגמה:
Flip(2,3); 1 1 3 4
COUNT_0 = 1
COUNT_1 = 1

25. שאלה 5
פתרון:
נשמור, בנוסף למטריצה, גם מערך Sum, שמכיל את סכום האיברים בשורות. כלומר, Sum[i] = מספר האחדות בשורה ה-i.
בנוסף, נשמור 2 מונים של מספר השורות המלאות ומספר השורות ללא אחדות כלל.
הדגמה:
Flip(2,3); 1 1 4
COUNT_0 = 1
COUNT_1 = 2

26. שאלה 5 קוד: init() fill A with 1’s fill Sum with n. count1=n count0=0
flip(i,j)
if (A[i][j]==0) {
A[i][j]=1;
if (Sum[i]=0)
count0- -;
Sum[i]++;
if (Sum[i]=n)
count1++; }
else {
A[i][j]=0;
count1- -;
Sum[i]--;
count0++; }
קוד:
init()
fill A with 1’s
fill Sum with n.
count1=n
count0=0
hasRowOf1()
return count1>0
hasRowOf0()
return count0>0

27. שאלה 6
שאלה: הציעו דרך לממש מערך של מספרים, כך שאתחול כל תאי המערך בערך INIT_VAL כלשהו יתבצע ב-O(1). להזכירכם – קריאה וכתיבה של ערך A[i] צריך לקחת O(1).

28. שאלה 6
פתרון:
כדי לאתחל מערך A בגודל n ב-O(1), ניצור ADT חדש בשם smartArray.
smartArray ישתמש במבני הנתונים הבאים:
A – מערך שישמור את הערכים
top – סופר את מס' התאים ב-A שאותחלו
INIT_VAL – ערך האתחול
C – מערך של ערכים מאותחלים + לא מאותחלים
C[0…top-1] – אינדקסים של תאים שאותחלו ב-A
B – מערך של אינדקסים לתאים מאותחלים ב-C
B[k] – האינדקס של k במערך C

29. שאלה 6 smartArray תומך במתודות הבאות: new: NewSmartArray(n)
A = new int[n]
B = new int[n]
C = new int[n]
Initialization:
init(val)
INIT_VAL = val
top = 0
The following procedure returns true if a given index ‘i’ is not initialized.
not_defined(i)
return !((B[i] < top) and C[B[i]] = i))

30. שאלה 6 Read(i) Write(i,val) if (not_defined(i)) if (not_defined(i))
Assumptions:
The value of an undefined element B[i] is an unexpected non-negative number. Thus, for an undefined index, the comparison B[i]<top can be either true or false.
The and expression is evaluated from left to right. Thus, C[B[i]]=i is evaluated only if B[i] < top.
Read(i)
if (not_defined(i))
return INIT_VAL
else
return A[i]
Write(i,val)
if (not_defined(i))
C[top] = i
B[i] = top
top++
A[i] ← val

31. שאלה 6
Example: x = new smartArray[n] x.init(0) x.write(2,20) x.write(4,40) x.write(5,50) a = x.read(4) >> the value of a is 40 b = x.read(3) >> the value of b is 0
222
379
151 5 4 3 2 1 50 5 4 3 2 1 2 5 4 3 2 1 40 1 20 5 4 2
top A B C

32. שאלה 7 נגדיר "מחסנית מינימום" כמבנה נתונים התומך בפעולות הבאות:
Create() – אתחול מבנה הנתונים.
Insert(x) – הכנסת איבר x למבנה.
RemoveLast() – הוצאת האיבר שהוכנס אחרון.
Min() – החזרת הערך של האיבר הקטן ביותר במבנה (ללא הוצאתו).
ChangeMin(k) – שינוי ערך האיבר הקטן ביותר במבנה ל – k.
הנחה: כל האיברים שונים זה מזה.
הציעו מימוש ל"מחסנית מינימום", כאשר
סיבוכיות הזמן הנדרשת לארבע הפעולות הראשונות היא O(1),
וסיבוכיות הזמן הנדרשת ChangeMin היא O(t),
כש – t הינו מספר האיברים במבנה שהוכנסו אחרי האיבר המינימלי (הכוונה לאיבר המינימלי לפני שהפעולה ChangeMin בוצעה).

33. שאלה 7 נגדיר "מחסנית מינימום" כמבנה נתונים התומך בפעולות הבאות:
Create() – אתחול מבנה הנתונים.
Insert(x) – הכנסת איבר x למבנה.
RemoveLast() – הוצאת האיבר שהוכנס אחרון.
Min() – החזרת הערך של האיבר הקטן ביותר במבנה (ללא הוצאתו).
ChangeMin(k) – שינוי ערך האיבר הקטן ביותר במבנה ל – k.
הנחה: כל האיברים שונים זה מזה.
פתרון:
נשתמש ברשימה דו-כיוונית
בנוסף, כל רשומה תכיל מצביע לערך המינימלי מבין הערכים הוותיקים יותר (כולל האיבר עצמו)

34. שאלה 7 פתרון: נשתמש ברשימה דו-כיוונית
בנוסף, כל רשומה תכיל מצביע לערך המינימלי מבין הערכים הוותיקים יותר (כולל האיבר עצמו)
הדגמה:
tail
head 5 7 3 15 10 6

35. שאלה 7 פתרון: נשתמש ברשימה דו-כיוונית
בנוסף, כל רשומה תכיל מצביע לערך המינימלי מבין הערכים הוותיקים יותר (כולל האיבר עצמו)
הדגמה:
אם נבצע ChangeMin(12), כיצד ישתנו החיצים?
tail
head 5 7 12 15 10 4

36. שאלה 7 פתרון: נשתמש ברשימה דו-כיוונית
בנוסף, כל רשומה תכיל מצביע לערך המינימלי מבין הערכים הוותיקים יותר (כולל האיבר עצמו)