מבני נתונים מופשטים בסיסיים רשימה a1 , a2 ,....,an : n = 0 רשימה ריקה a a a לפני משמעויות : ראשון : 1 אחרון : 2 מקום : i מבנה נתונים a i 1 : L:LIST P:POSITION המקום האחרי - אחרון (END(L : פעולות : יתכנו הרבה אנחנו מעניינים.
Download ReportTranscript מבני נתונים מופשטים בסיסיים רשימה a1 , a2 ,....,an : n = 0 רשימה ריקה a a a לפני משמעויות : ראשון : 1 אחרון : 2 מקום : i מבנה נתונים a i 1 : L:LIST P:POSITION המקום האחרי - אחרון (END(L : פעולות : יתכנו הרבה אנחנו מעניינים.
מבני נתונים מופשטים בסיסיים
רשימהa1 , a2 ,....,an :
n = 0רשימה ריקה
a
a
aלפני
משמעויות :ראשון:
1
אחרון:
2
מקום:
i
מבנה נתונים
a
i 1
:
L:LIST
P:POSITION
המקום האחרי-אחרון(END(L
:
פעולות:
יתכנו הרבה
אנחנו מעניינים בישום השמטת כפולים
צריך :מציאת ראשון ,סריקה ,קריאה ,השמטה.
: פעולות
1. INSERT (X, P, L)
: ברשימהP אם יש
a1, a2,…..,ap-1, x, ap,….,an
(P=END(L :אם
a1, a2,…..,an,x
Undefinedאחרת
:
2. LOCATE(X, L)
x.מקום ראשון של
(END(Lאם לא מופיע
3. RETRIEVE (P,L)
- L. נמצא בP מוגדר רק אם
4. DELETE(P,L)
a1, a2,…..,an
a1, a2,…..,ap-1,ap+1,….,an
-L. בP מוגדר רק אם
5. NEXT(P,L), PREVIOUS(P,L)
מוגדר טבעי
6. MAKENULL(L)
7. FIRST(L)
ישום השמטת כפולים
Procedure PURGE (Var L:LIST)
Var
p,q: Position
{p = Current, q = Search}
begin
(1)
p:= FIRST(L)
(2)
while p<>END[L] do begin
(3)
q:= NEXT(P,L)
(4)
while q<>END(L) do
(5)
if same (RET(p,L), RET(q,L))
(6)
then DELETE(q,L)
(7)
else
(8)
q:= NEXT(q,L)
(9)
p:= NEXT(p,L)
אינו מקודםq
end;
כי הרשימה
end; {PURGE}
.התכווצה
ישומים של מבנה הנתונים
) רשימה מקושרת (סמנים,מערך
ישום במערך
1st element
2nd “
last
רשימה
Last element
ריק
Maxlength
Const
maxlength = 99
type
LIST = record
elements: array[1..maxlength] of element type;
last: integer
end;
Position: integer;
function END(var L:LIST): Position
begin
returm(L.Last+1)
end;
ישום ברשימה מקושרת (רגילה)
a2
an
a1
header
LIST
POS3
)POS.END(L
POS2
כל תא מורכב מ:
ערך האיברמצביע לאיבר הבא ממוש עם מצביעים
תשומת לב : Positionעל האיבר “שלפני”.
ערך האיבר במקום Pהינו:P .next .element
-למה :כדי לבצע DELETEיעיל.
POS1
:הגדרת הרשימה
type
celltype = record
element: elementtype;
next:celltype;
end
LIST = celltype
Position = celltype
: בצוע לא יעיל
END[L]
)(צריך לרוץ על כל הרשימה
Function END (L:LIST) : position ;
{returns a pointer to the last cell of L }
Var
q: position
begin
Q:= L ;
while q . next < > nil do
q:= q . next ;
return (q) ;
end ; (END)
ישום רשימות באמצעות סמנים
)(CURSORS
• שימוש באינדקסים
(בתוך מערך) במקום מצביעים.
1
H
2
3
4
L
5
6
7
8
9
10
next
element
• מאחסנים כמה רשימות ( +רשימת פנויים)
• אחרון מצביע על .0
• ריקה -כששם האחרון מצביע על .0
R
:דוגמה
L
M
5
1
Avail
9
1
n
7
2
-
4
3
s
0
4
-
0
5
y
8
6
-
2
7
o
0
8
e
3
9
-
10
10
-
11
6
11
L: y, e, s
M: n, o
Avail: 9, 10, 11, 6, 2, 4
הוספת והשמטת איברים
)(מרשימת הפנויים
DELETE
INSERT
MOVE .צריך
בצוע הזזה
שים לב :כמו ברשימות מקושרות התייחסותנו לתא
היא דרך המצביע עליו!!!!
העברת התא ” “pלפני התא“q”:
3
p
4
2
q
1
temp
התא ש - pמצביע עליו יזוז לפני התא
ש -qמצביע עליו.
שיטה( :לא לאבד תאים)!
א) לסמן בtemp
ב) להעביר סמנים שניתן לשחרר.
השוואת יישומים
סמנים
קריטריון
מערך
מקושרת
גודל מקסימלי
מוגבל
“לא מוגבל”
INS/DEL
(N)
(1)
(1)
PREVIOUS
(1)
(N)
(N)
END
(1)
”“(N)
”“(N)
Position
ישיר
משתנה (יחסי)
משתנה (יחסי)
נצילות מקום
מבוזבז
“לא מבוזבז”
מבוזבז “פחות”
דרישת מקום
מקום * 1מקום +מצביעים מקום +סמנים
מוגבל/בסה”כ
רשימה מקושרת כפולה
:מגבלות מקושרת רגילה
(END(L מציאת סוף1.
) ללכת הפוךPREVIOUS (מציאת קודם2.
מבלבל3. Position
מקושרת כפולה:פתרון
X
Y
Z
type
celltype = record
element: elementtype;
next, previous:celltype;
end ;
Position = celltype
DELETEפשטות ביצוע
ישום התחלה וסוף:
אפשרות א’:
איבר ראשון ואחרון מצביעים עלNIL.
HEAD
אפשרות ב’:
סגירה מעגלית (הצבעה על) HEAD
HEAD
השוואת רשימה כפולה לרגילה
יתרונות
• קלות בהליכה אחורנית
• קלות במציאת הסוף
• פשטות בהתייחסות למקום
חסרונות
• פי שניים מקום וזמן.
מבני רשימות מיוחדים
מחסניתSTACK
• ניתן לגשת רק לראש.
•LIFO
• דוגמה :מחסנית רובה
ניירות על השולחן
פעולות:
)1. MAKE NULL (S
)2. TOP (S
)3. POP (S
)4. PUSH (S
)(TRUE | FALSE
)5. EMPTY (S
ישומים:
• כל הרשימות בהגבלת טיפול רק בהתחלה.
• רשימות מקושרות או סמנים :בסדר.
• מערך -בסדר .אבל בעיות יעילות.
( כל הכנסה והוצאה(O(N ) :
ייעול :
1
2
3
1st
TOP
2nd
:
Last Element
MAXLENGTH
Type
STACK = record
top: integer
]elements: array [1…MAXL] of element type
; end
שימושים :ברקורסיות
ישום פעולות :פשוט .לבצע לבד.
Queueתור
• סוג מיוחד של רשימה
FIFO•
- FRONT .יוצאים ב- REAR , • נכנסים ב
F
R
:פעולות
1) MAKENULL (Q)
2) ENDQUEUE (X,Q) : INSERT (X,END (Q),Q)
3) FRONT (Q) : RET (FIRST (Q), Q)
4) DEQUEUE (Q) : DELETE (FIRST (Q), Q)
5) EMPTY (Q) : TRUE | FALSE
ישום
• כל היישומים הקודמים עובדים (רשימות)
• ליתר יעילות :יישום מיוחד.
+צריכים לגשת לסוף
+יישום ברשימה מקושרת חד כיוונית.
• איבר אחד ריק (נוחיות טיפול
ברשימה ריקה)
• מצביעים על התחלה וסוף.
TYPE
QUEUE : Record
front, rear : celltype
:דוגמאות לפעולות
MAKENULL (Q)
F
R
Q
F= R
EMPTY
ENQUEUE (X)
F
R
X
ENQUEUE (Y)
F
R
X
Y
DEQUEUE (Q)
F
R
Y
יישום תור במערך (מעגלי)
2
N
1
1
N
2
Q.FRONT
QUEUE
REAR, FRONTנעים עם השעון FRONTעל ראשון , REAR -על אחרוןF = R איבר בודד
F = R + 1 ריק
F = R + 2 מלא
שימו לב :ניתן להכניס רק N-1איברים!!!!!!
עבור כל Fיש רק Nאפשרויות ל - Rולכן ניתן לייצג רק :
0,1,2,……., N-1
Q.REAR
ישום פעולות תור מעגלי:
פשוט .לבצע לבד.
Mappingעמודים AHO.61-65
שמוש מחסנית לבצוע רקורסיות
• בצוע קריאה לסברוטינה רגילה:
גורם במחשב לשימור
המשתנים וכתובת חזרה,
ואז קפיצה לשגרה.
• בצוע חזרה מסברוטינה רגילה
קריאת המשתנים ועדכונם
וחזרה לכתובת החזרה
Subroutine B
Prog A
.
.
.
.
.
.
i =9
i = 15
.
Call B
.
.
.
.
return
.
סברוטינות רקוקסיביות
עקרון דומה -אך הקפיצה היא לאותה שגרה.
יכול לקפוץ הרבהפעמים (“לא חסום(”
פתרון :שמור המשתנים וכתובת החזרה
בתוךSTACK.
בכל קריאה לרקורסיה:
הכנסת משתנים וכתובת-(PUSH(S
חזרה למחסנית
בכל חזרה מרקורסיה:
הוצאת משתנים והכתובת(POP(S
מהמחסנית ועדכון .
בצוע חזרה לפי כתובת החזרה.
ישום רקורסיה בשפה שאין רקורסיה
• נבצע אותו הדבר ,אבל בעצמנו.
• נחזיק STACKשבו:
)1כל המשתנים הלוקאלים.
)2כתובת חזרה.
)3פרמטרי הקריאה .ערכם מוחזרים.
(לא הכרחי)
)Function FACT(N
(1) If N <= 1 then
)return (1
(2) ELSE begin
)M:= FACT(N-1
)(3
)Return(N*M
)(4
(5) END
ישום לולאה באמצעות רקורסיה
While X do
)
( SUBROUTINE WHILE
IF X then do begin
) ( CALL WHILE
ELSE RETURN
END
תשומת לב:
כל המשתנים שמשתנים במשך הלולאה
וערכם הקודם משומש בלולאה הבאה
צריכים להגיע כפרמטרים או כגלובאלים.
טבלאות דינאמיות
)(cormen 18.4 , p.367
• מתאים ל - STACK, QUEUE
בישום מערך.
• יתאים גם לHASH, HEAP
מטפל בבעיית חוסר המקום,
שנוצר דינאמית במבנה מבוסס
מערך.
דוגמה :מחסנית מבוססת מערך -
מה עושים כשמתמלאת?
פתרון( :אלגוריתם)( :שיטת ההכפלה)Doubling
)1הקצה מקום מסויים לטבלה (פשוט): N2i
)2כשהמקום מתמלא והטבלה מכילה N
אלמנטים:
א) הקצה מקום חדש לטבלה בגודל N2N
ב) העתק איברים לטבלה החדשה.
ג) שחרר טבלה ישנה.
סבוכיות
)1עבור פעולת )PER OPERATION) : INSERT
• אם אין הכפלה(O(1
• אם יש הכפלה(O(N
)2) AMORIZED ANALYSIS CORMEN 356-363) AMORTIZED COST
• חשוב זמן ממוצע פר פעולה במקרה הגרוע ביותר.
• שווה ל : T(n)/n ,כאשר (T(nהוא סכום הפעולות על nאיברים.
• שיטת ההתחשבנות)(ACCOUNTING
• מחשבנים לפעולה עלות מסויימת.
• עשויה להיות גבוהה או נמוכה ממה שעולה.
• כשהעלות המחושבת גבוהה מהעלות בפועל שומרים Credit
לעצמים (איברים) אחרים.
3) Amortized Complexityשל שיטת ה- Doubling :
א) חישוב ישיר:
עלות כוללת של nאיברים:
• nהכנסות.
• העברות:
1+2+4+8+ … + n
= 2n-1
(T(n)=O(n
יותר מדויק- T(n)=3n
עלות מהוונת)(Amortized
T(n)/n = 3
ב) חישוב בשיטה החשבונאית)(accounting
הכנסת
איבר
n
n/2
בעת הכנסת איבר מחשבים לו
עלות 3
1עבור הכנסתו. 1עבור העברתו בהעברה הבאה. 1כ”תרומה לחבר” (אחד מה ) - n/2עבור העברתו בהעברה הבאה.
עציםTrees
עץ = מבנה הררכי
הגדרה רקורסיבית:
1.צומת בודד .זהו גם שורש העץ.
2.אם nהוא צומת ו T1….TKהינם עצים ,ניתן
לבנות
עץ חדש שבו nהשורש ו T1….TKהינם“ תתי
עצים”.
n
TK
...
TK
מושגים:
צומת= Node
עץ= Tree
שורש= Root
תת-עץ= Subtree
T1
T1
n
דוגמה :פרקים וסעיפים בספר
book
c3
c2
c1
s1.1 s1.2 s1.3 s2.1 s2.2 s3.1
book
c1
s1.1
s1.2
s1.3
c2
s2.1
s2.2
c3
s3.1
מושגים:
bookהורה( /Parentאבא) שלc1, c2, c3c1, c2 -ילדים /childrenשלbook
s2.1צאצא( /Descendantלא ישיר) שלbook n1, n2,…nkמסלול /Pathאם כ”א הורה של הקודם)
(
אורך המסלול = מס’ הקשתות
מס’ הצמתים (פחות אחד)
=
צומת ללא ילדים = עלה/Leaf
n1 -אב קדמון /Ancestorשלnk
תת-עץ -צומת עם כל צאצאיו
גובה העץ -אורך המסלול הארוך ביותר מהשורש
לעלה). (height
עומק צומת -אורך המסלול מהצומת לשורש.
)(depth
סדר בצמתים
בד”כ -משמעות לסדר הילדים .מסדרים משמאל לימין.
a
b
a
C
C
אם הסדר לא חשוב -עץ לא מסודר
)(unordered tree
b
צורות ססטמיות לסריקת הצמתים בעץ
Preorder , postorder , Inorder
הגדרה רקורסיבית:
• אם Tהוא ריק -אזי הרשימה הריקה היא Preorder
)(POST, IN
• אם Tהיא צומת בודד ) (nאזי הרשימה הבנויה מ - nהינה
)Post,In) .Preorder
• אחרת אם Tהוא עץ עם שורש nותתי עצים T1,…,Tkאזי:
: PREORDER
)n, PRE(T1(, … , PRE)TK
: POST
POST (T1(, … , POST )TK), n
: IN
)IN(T1), n , IN(T2(, … ,IN)TK
Procedure PREORDER (n: node)
(1) list n ;
(2) for each child c of n, in order from
left do:
PREORDER (C)
end ;
. בביתPOSORDER, INORDER להשלים כתיבת
1
:דוגמה
2
4
3
7
5
8
6
1,2,3,4,5,6,7,8
: PRE
3,2,5,4,6,1,7,8
: IN
3,5,6,4,2,7,8,1
: POST
שיטה למספור:
הקף העץ בכיוון הפוך לשעון:
1
2
4
3
8
6
PRE:סמן צומת בפעם הראשונה.
IN :סמן עץ בפעם הראשונה.
סמן צומת פנימי בפעם השניה.
POST:סמן צומת בפעם האחרונה.
5
עצים מסומנים ועצי ביטויים
)(Labeled Trees, Expression Trees
עצים מסומנים :מסמנים את הצומת בסימון כלשהוא.
עצי ביטויים :העץ מייצג ביטוי מתמטי.
דוגמה:
)= (a+b)*(c+d
*
n1
+
+
n3
d
n7
n2
c
n6
b
n5
a
n4
חוקיות הביטוי בעץ ביטויים:
1.כל עלה מסומן באופרנד.
2.צומת פנימי מסומן בפעולה( אופרטור)
בינארי ו - E1,E2הינם ערכי הביטויים
ואם האופרטור
המבוטאים ע”י תתי העץ אזי הביטוי הוא :
E2
3.אופרטור אונרי -ילד יחידי.
E1
סדר הסריקה של עצי ביטוי קובע יצוג שונה של הביטוי -
1. Inorderהיצוג הרגיל)(a+b)*(c+d( 2. Postorderפולני )
ab + cd +
d
(
מחשבוני)HP
(
אין כפל משמעות)!!
שימוש במספור לאינפורמציה שושלת
אם POST :
112
X
)Y= desc(x
y
50
צמתים
63-112
)Post(x) - #desc(x) <= Post(y) <= Post(x
מבנה נתונים אבסטרקטי של עץ
פעולות שיעניינו אותנו:
(1. PARENT (N, Tהחזר את אבא של nבT.אם nהוא השורש החזרNil.
(2. LEFTMOST_CHILD(n, Tהחזר הבןהשמאלי ביותר של nבעץ Nil. Tאם nעלה.
(3. RIGHT_SIBLING(n, Tאח ימני של nב Nil. Tאם אין.
(4. LABEL(n, Tסימון nב T.( לא נדרש תמיד).
(5. CREATi(r, T1,…Tiיוצר עץ חדשעם שורש rשבו:
א ) rהשורש מסומן בU
ב) ל rיש iבנים , iתתי עצים. T1,…Ti
עץ עם שורשr.
מחזיר
i=0
rגם שורש וגם עלה.
. אם ריקNil החזרת השורש או6. ROOT(T -(
T.יוצר את העץ הריק7. MAKENULL(T -(
ADT בעזרת הPREORDER כתיבת:דוגמה
Procedure PREORDER (n: node)
{list the descendants of n in PREORDER}
var c: node;
Begin
print (LABEL (n, T))
c := LEFTMOST_CHILD(n, T);
while c <> Nil do begin
PREORDER(c);
c := RIGHT_SIBLING(c, T)
end;
end; {PREORDER}
כתיבה לא רקורסיבית שלPREORDER
• נלך במורד העץ שמאלה ככל שנוכל
•כשלא ניתן נעבור לאח הימני של הצומת האחרון
אם אין -נעלה למעלה ונזוז לאחיו הימני
1
2
9
8
3
7
6
4
5
בצוע וישום:
• נחזיק מחסנית ובה נאחסן בכל רגע את
המסלול
מהשורש עד לצומת שבה אנו מבקרים.
מחסנית רקורסיה
ישום עצים שרירותיים
כל צומת מכילה 3מצביעים:
בן שמאליאח ימני-הורה
(אופציונלי)
a
c
d
g
b
f
ניתן לחשב באמצעות מצביעים או באמצעותCursors
e
עצים בינאריים
עץ ריק או לכל צומת יש תת קבוצה של{ ילד ימני ,ילד שמאלי}
דוגמא:
1
2
5
6
1
4
2
5
3
7
6
4
3
7
הנ”ל:
זהים בעצים מסודריםשונים בעצים בינארייםסדרי סקירה:
Pre, Postיתנו תוצאה זהה למה שיתנו בעץ סדור.In -לא בהכרח זהה!
ייצוג:
)1מערך של רשומות
Var
cellspace: array[1…maxnodes] of record
leftchild: integer
rightchild: integer
;end
דוגמא :קודHuffman
נתון סט של אותיותa, b, c, d, eמופיעות בשפה בהסתברויות שונות:0.12, 0.4, 0.15, 0.08, 0.25
רוצים לקודד ל 0/1בצורה יעילהאפשרות א ’ -שלשות:
אורך ממוצע3 :
000
001
010
011
100
אפשרות ב’ -ייצוג קצר לאותיות קצרות
ייצוג ארוך לאותיות ארוכות
שימוש בקוד פרפיקסי =
אף אות אינה פרפיקס של אחרת
a
b
c
d
e
דוגמא:
000
11
01
001
10
אורך ממוצע:
3(0.12+0.15)+2(0.4+0.08+2.5)=2.27
a
b
c
d
e
בעיה :בהינתן אותיות והסתברויות מצא
קוד פרפיקסי יעיל.
יצוג קוד פרפיקסי בעזרת עץ בינארי:
אותיות בעלים- 0/1בענפים (שמאל= ,0ימין=)1
-אותיות בעלים
1
1
מבטיח פרפיקס
ישוםHuffman
יהיה לנו יער (אוסף עצים)העלים = אותיותמסלולים = סיומות של מיליםלכל עץ משקל = סכום ההסתברויות-כל פעם שדך את העצים הקלים ביותר
0
0
0
1
1
0
:דוגמא
0.12
a
.
0.4
b
0.15
c
.
0.08
d
.
0.25
e
.
.
0.2
X1
X2 0.35
X3 0.6
1.0 X4
X4
X3
:חישוב אורך ממוצע
b 0.4
X2
X1
a 0.12
e 0.25
c 0.15
d 0.08
a
d
c
e
b
0.12*4
0.08*4
0.15*3
0.25*2
0.4*1
2.15
מבנה נתונים:
)1לשמור את מבנה העצים :לכל צומת אבא ובנים.
1
2
3
4
5
6
7
Lchild
Parent
Rchild
)2לכל עץ משקלו ושורשו.
Weight Root
Forest
)3שמירת האלף-בית (סטאטי)
1
2
3
4
5
0.12
0.4
0.15
0.08
0.25
a
b
c
d
e
ALPHABET
דינמיות
בכל פעולה מוסיפים צומת -מורידים עץ.הוספת צומת -בסוף שלTREEהורדת עץ :מ T1ו T2יוצריםT.נבצעT2+T1
T1
זריקת T2:החלף מקומות בין T2וTLASTוהקטן האינדקס לLAST
עצים בינאריים:
ניתן לישם באמצעות פוינטרים:
type
node = record
lchild : node
rchild : node
parent: node
end
אחסון עצים בינאריים במערך:
• טוב למבנה סטאטי
• אם צומת xבתאi :
אז :
Ichild(x): 2i
Rchild(x): 2i+1
• טוב במיוחד אם העץ מושלם (או שתילת
עצים אחרים בחורים).
X96
3.43
ישום עצים
יצוג עץ באמצעות מערך (מערך הורים) :
• יצוג פשטני התומך ב- PARENT
• מערך [A[iשבו [A[iהוא סמן ) (Cursorלהורה שלi :
• בעיה לתמוך ב- LEFTMOST_CHILD
RIGHT_SIBLING
• ניתן לייצג( LABELבמערך נוסף)
a
דוגמה:
e
0 1 1 2 0
T:
1
b
2
3
c
1 2 3 4 5
d
5
a b c d e
4
LABEL
1 2 3 4 5
בעיית LCHILDו - RSIBLING:לא מוגדר סדר מספיק
ביצוג הנוכחי!
נניח :נשכן בנים אחרי האב ומשמאל לימין.
X96
3.44
R_SIBLING ישום- אזי
Function R_SIBLING (n:node ; T:Tree)
node ;
{return R_SIB of n in T (o else) }
var
i,parent: node ;
begin
parent:= T(n)
for i:= n+1 to max nodes do
if T(i) = parent then
return (i) ;
return (0) ;
end ;
DATA TYPES
type
node = integer
TREE = array [ 1 … max nodes ]
of node ;
X96
3.48
איך מבצעים(CREATEz (v,T1,Tz:
)1צור רשימה חדשה Vותן לה סימון מתאים
(בד”כ נשמור רשימת Availלתאים פנויים)
)2
V. left = T1
)Z
T1.right = T2
X96
3.49
ישום ברשימת מצביעים (זהה) !
A
rsibling
label
C
lchild
B
D
A
C
B
D
שידוך עצים ברשימת מצביעים
?
T1
?
T2
Avail