שיעור עשירי: מיונים – ב

מבנה נתונים, המכללה לבנות י-ם תשס"ח - 2008

שיעור עשירי:

מיונים – ב'

מקורות נוספים:

מבוא לאלגוריתמים 7פרק

תודות לד"ר ראובן חוטובלישחומרי ההוראה שלו סייעו בהכנת המצגת

תור עדיפויות

*( הוא טיפוס אוסףpriority queue) תור* עדיפויות•המטפל בנתונים בהתאם לעדיפויות שלהם:

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

הראשון לטיפול הינו בעל העדיפות הגבוהה ביותרתור כאן - לא במשמעות של טיפוס הנתונים המופשט "תור"! *•

טיפוס נתונים מופשט*•

שימושים בתור עדיפויות

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

תהליכים

ייצוג תור עדיפויות בעזרת רשימה

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

100 20 20

עדיפות מקסימלית

ייצוג תור עדיפויות בעזרת רשימה

האיבר בעל העדיפות הגבוהה ביותר נמצא•

תמיד בראש הרשימה)O)1 האיבר ה"עדיף" ביותר נעשית ב- מציאת•)O)1 האיבר העדיף היא ב-מחיקת• = מס' O)n(( n נתון חדש לוקחת הכנסת•

מקום להכנסה לפי סדר עדיפויות[לחפש]צריך האיברים באוסף(

ייצוג תור עדיפויות בעזרת עח"ב

נחזיק עץ חיפוש בינרי הממוין לפי עדיפויות:•

כך האיבר בעדיפות המירבית יהיה

תמיד בצומת הימני ביותר:

ייצוג תור עדיפויות בעזרת עח"ב

, )O)1 האיבר העדיף תיעשה ב-מציאתכדי ש•נחזיק מצביע אליו )אותו יש לעדכן בעת

הכנסות/מחיקות( נתון חדש הכנסת האיבר העדיף ומחיקתפעולות •

)תלוי כזכור במבנה העץ( בממוצע )O)log nלוקחות

ייצוג תור עדיפויות בעזרת ערימה

)טיפוס(( היא מבנה נתונים heap)ערימה •המאפשר מציאת איבר מקסימלי בין הנמצאים

:)O)1בערימה ביעילות מקסימלית

ייצוג תור עדיפויות בעזרת ערימה

האיבר העדיף מחיקת

נתון חדש הכנסתו

במקרה הגרוע )O)log nייקחו:

ממשק טיפוס הנתונים ערימה

•Heap)( הפעולה בונה ערימה ריקה – (init)•insert )x( הפעולה מכניסה ערך – x-לערימה ב O)log n(

•extractMax)( – הפעולה מוציאה את האיבר המקסימלי

מהערימה ומחזירה אותו )O)log nב-

•retrieve)( או( findMax)( הפעולה מחזירה את הערך - ) המקסימלי בערימה מבלי למוחקו

)O)1ב-

•buildHeap )values( הפעולה בונה ערימה עם הערכים – )O)n הנתונים ב-

עקרונות מימוש הערימה

הערימה היא עץ בעל צורה מסוימת•מטרות הערימה:•

יעילות )בדומה לעץ חיפוש בינרי(–פשטות המימוש )יותר פשוט מעץ חיפוש בינרי(–

נשיג ע"י סידור צומתי העץ בצורה יעילותאת ה•"סדר הערימהמסוימת – נקרא לזה "

כמעט עץכ נשיג ע"י מימוש העץ פשטותאת ה•מערך בתוך מלא

עץ בינרי מלא וכמעט מלא

עץ בינרי כמעט מלא

בו ברמה הוא עץ בינרי

של העלים, חסרים )אולי(

כמה עלים ימניים ביותר:

מימוש עץ בינרי כמעט מלא במערך

אפשרי כאשר ידוע • על nחסם עליון

מספר הצמתים בעץ

0123456789101112131415

i j k l m n oh

9 10 11 12 13 14 158

dba e fc g i j k l m n oh

מבנה הנתונים - ערימה )בינרית(

מערך המייצג עץ בינרי כמעט מלא •לכל צומת בעץ – מתאים תא במערך•למערך יש שתי תכונות:•

. אורך המערך 1. מספר האיברים המשמעותי 2

(size < length) המאוחסן במערך

מבנה הנתונים - ערימה )בינרית(

קיים קשר ברור בין צומתי העץ והאינדקסים של •המערך:

(]0[arr)לא משתמשים ב ]arr]1שורש העץ יושב לעולם ב-

)ערך שלם במערך i/2 מאוחסן בתא iהורה של צומת תחתון(

2i מאוחסן בתא iבן שמאלי של צומת 2i+1 מאוחסן בתא iבן ימני של צומת

ייצוג הערימה 1 2 3 4 5 6 7 8 9 10

16 14 10 8 7 9 3 2 4 1

1421098

תכונת הערימה )בינרית( נקבע בעזרת:)קובע את היעילות( סדר הערימה

תכונת הערימה:•, פרט לשורש, מתקיים:iלכל צומת

ערך כל צומת קטן-שווה מהערך השמור בהורה של הצומת

: ערך צומת הוא לכל היותר ערך ההורה במילים אחרות. שלו

שאלות הבהרה:היכן נמצא הערך הגדול ביותר בערימה? •ערך שצומת מכיל, גדול או שווה לכל הערכים ....? •

סיכום ביניים

של הערימה נמצא בשורש המקסימליהאיבר •.1כלומר בתא מספר

מהרקורסיביות של הגדרת הערימה נובע כי •לכל צומת, תתי העץ של הצומת הם ערימות.

העלים של העץ הם איברי החלק השני )הימני( •של המערך.

כמה עלים בערימה? :1טענה •

, כלומר:arr אורכו של מערך nיהי

n = arr.length

]arr])n/2+1( …nהאיברים בתת מערך

המייצג ערימה בינרית, הם כולם עלים.

: מחצית מאיברי הערימה הם עלים.מסקנה

גובה של ערימה

: גובה של עץ ערימה בינרית 2טענה • צמתים, הואnבעל nlog

מימוש פעולות הממשק של ערימה

הפעולה הבונה: חסם עליון של מספר n+1 (nהקצאת מערך בגודל

האיברים בערימה(

לאפס sizeאתחול •

)O)1יעילות הפעולה בייצוג הנתון:

מימוש פעולות הממשק של ערימה

– מחזירה את האיבר extractMaxהפעולה הגדול:

]arr]1החזרת •

)O)1יעילות הפעולה בייצוג הנתון:

שמירה על מבנה הערימההדבר המשמעותי ביותר הוא השמירה על מבנה

הערימה, כלומר על תכונת הערימה)…(heapIfYהפעולה תקרא: •

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

עצמו -]arr]i שייתכן, הם ערימות אך iהאינדקס מפר את הסדר ויש לשבצו למקומו.

הפעולה תחליק את האיבר למקומו בערימה, המהלך: יהפוך לערימת מקסימום.]arr]iכך שהעץ ששורשו ב-

מערך המייצג ערימת מקסימום. הפלט:

אלגוריתם לשמירה על מבנה הערימהheapIfY (arr, i)

step1+2. l Left)i( r Right)i(

Step3 if l arr.heapSize and arr]l[ > arr]i[

then largest l

else largest i

step4 if r arr.heapSize and arr]r[ > arr]largest[

then largest r

step5 if )largest != i( {exchange arr]i[ arr] largest[}

heapIfY)arr, largest(

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

• largest = l if arr]l[ > max )arr]r[,arr]i[( r if arr]r[ > max )arr]l[,arr]i[(

• i if A]i[ > max )arr]l[,arr]r[(

בכל שלב נקבע האיבר הגדול ביותר • והאינדקס שלו ]arr]right)i([,arr]left)i([,arr]iמבין

.largestמוצב ב- אז סיימנו!largest=iאם

heapIfYדוגמה לפעולה

heapIfY(arr,2)

שמירה על מבנה הערימה i בצומת המושרש הוא הגדול ביותר אזי תת-העץ ]arr]i אם•

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

arr]largest[ -ו arr]i[ .מוחלפים זה בזה ובניו מקיימים את תכונת הערימה.iלאחר ההחלפה הצומת • ]arr]i מכיל עתה את הערך המקורי largestאולם הצומת•

מפר את תכונת הערימה.largest ב-המושרששתת העץ יתכן ו עם תת עץ זה.heapIfYלכן יש לקרוא באופן רקורסיבי ל- •

heapIfYהמשך הדוגמה:

heapIfYיעילות הפעולה הפעולה מבצעת סדרת החלפות על מסלול כלשהו

משורש העץ לעלה. על כל החלפה מתבצע מספר קבוע של פעולות •

(.swap)שתי השוואות ו-לכן, מספר הפעולות במקרה הגרוע הוא כגובה •

העץ., אזי סדר log nמכיוון שגובה העץ חסום על ידי •

הגודל של זמן הריצה של הפעולה כולה הוא O)log n( .

buildHeapבניית ערימה – הפעולה ]n = length]arr כאשר arr מערך קלט:ה ערימה הפלט:•

]arr])n/2+1( …nמכיוון שהאיברים במערך של העץ, הרי שבתחילת התהליך כל אחד עליםכולם

מהם הוא ערימה בת איבר יחיד. אם כך נוכל להפוך את המערך הנתון לערימה תוך

שימוש )מהסוף על התאים שבתחילת המערך heapIfYב-

להתחלה(באופן הזה:

buildHeapבניית ערימה – הפעולה

buildHeap (arr)

heapSize]arr[ length]arr[

for i length]arr[/2 downto 1 do heapIfY )arr, i(

על צומת HeapIfYהזמן הנדרש להרצת •,)O)h הוא hשגובהו

בגובה זה ישנם צמתים •לכל היותר.

12/ hn

buildHeapלכן זמן הריצה הכולל של •הוא:

hbecause

: מסקנה

הזמן הדרוש לבניית ערימה הוא לינארי

)O)nבמספר הצמתים בה:

buildHeapבניית ערימה – הפעולה

buildHeap (arr)

heapSize]arr[ length]arr[

for i length]arr[/2 downto 1 do heapIfY )arr, i(

משך זמן הריצה הוא ...

ניתן לבנות ערימה ממערך לא ממוין בזמן לינארי!

הוצאת מקסימום מערימהextractMax הפעולה

extractMax (arr)

max arr]1[; arr]1[ arr]heapSize]arr[[;

heapSize]arr[ heapSize]arr[-1;

heapIfY )arr,1(

return max

משך זמן הריצה הוא ...

extractMaxהדגמה: הפעולה

:)extractMax)Hנבצע •

extractMaxעוד פעם •)H(:

65 43 10 15 29

הכנסת איבר לערימהinsert הפעולה

)איך זה יראה בעץ בינרי?( למערךכעלה אחרון xהכנס את 1.

-sift)הפעולה נקראת גדול מאביו, החלף ביניהם xכל עוד 2.up )

, כי גובה העץ )O)log nמשך זמן הריצה של הפעולה log nהוא

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

(size)

הכנסת איבר לערימהinsert הפעולה

insert (arr, key)

heapSize]arr[ heapSize]arr[+1

i heapSize]arr[

while i>1 and arr]parent)i([ < key do{

arr]i[ arr]parent)i([ i parent)i(

arr]i[ key

בין הערכים במערך אלא רק הזזה החלפהשימו לב שאין ...של הקטן למקומו

insert הדגמה: הפעולה3978

2 14 15

2 14 7

15הכנסת הערך

נעקוב בעזרת המערך המתאים:

insert הדגמה: הפעולה

:)insert)H, 43נבצע •

:)insert)H, 30נבצע •

insert)H, 95(:76נבצע •

65 43 30 95

ערימת מקסימום וערימת מינימום

וערימת מקסימוםמבדילים בין ערימת • מינימום

בערימת מינימום, כל הורה בעץ קטן משני •ילדיו או שווה להם.

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

heap sort ערימה *מיוןרעיון האלגוריתם הכללי:

, ניתן למיינו באופן הזה:n בגודל arrבהינתן מערך

n = arr.lengthנבנה ערימה ממערך הקלט,

. ]n[arr. ניתן להחליפו עם -]arr]1בתום הבנייה האיבר הגדול נמצא ב

, heapSizeאם מסלקים את הערך הזה מהערימה על ידי הקטנת ניתן

בקלות להפוך את המערך המקוצר לערימה בעזרת זימון אחד של

heapIfY .)רק השורש יכול להיות לא במקום ויש לשמור את תכונת הערימה(

והלאה עד ערימה n-1תהליך זה יחזור על עצמו עבור ערימה בגודל

:2בגודל

בדברנו על מיון אנו מתכוונים למיון בסדר עולה!*

heap sortמיון ערימה heapSort (arr)

buildHeap)arr(;for i=length]arr[ downto 2

exchange )arr]1[, arr]i[( heapSize]arr[ =heapSize]arr[-1 heapIfY)arr,1(

heap sortמעקב אחר

1,2,3,4,7,8,9

heap sortזמן הריצה:

במקרה )O)n log nזמן הריצה של מיון ערימה הוא הגרוע.

נסביר:

)O)n הוא buildHeapזמן הריצה של

)O)log n הוא heapIfYזמן הריצה של כל זימון בודד של

מיון ערימה )טוב כמו מיון מיזוג()O)n log nיהיה ביעילות •יתבצע במקום )כמו מיון הכנסה ובחירה(•

מאחד את היתרונות במיונים השונים•היתרונות נצברים מאופן השימוש במבנה הנתונים מערך •

כערימה.

למרות האלגוריתם הטוב, מימוש טוב של מיון מהיר יהיה •מהיר ממנו ביישומים מעשיים!

הערימה כמבנה נתונים משמשת ליישומים נוספים •)תור קדימויות ראינו(

שיעור עשירי: מיונים – ב

Documents

הכנה למועד ב

חידון שמואל ב

קטלוג premium פסח 2016 - חלק ב

נוירו שיעור 5

שיעור מס' 1 - themarker...

חזרה למבחן ביום ב

תכנות – שיעור 7

קורס תכנות – סמסטר ב' תשס"ח

שיעור פלסטלינה - תוכי

נצרות שיעור 3

נצרות שיעור 4

שיעור מספר 6

ציר זמן חלק ב' סולידרנו

אופטיקה – שיעור 3

שיעור 3 לאתר)

מתמטיקה ב' לכלכלנים

סיכום שיעור קניין

סיכומי שיעור

שיעור חזרה

פיזיולוגית סמסטר ב