מבני נתונים ויעילות אלגוריתמים מכללת אורט כפר-סבא מבני נתונים ויעילות אלגוריתמים חסמים אסימפטוטיים חיפוש לינארי וחיפוש בינארי מיון בחירה (Selection Sort) 17.09.14 אורי וולטמן uri.weltmann@gmail.com

חידה לחימום ספירלה משורטטת על דף, ולאורכה 25 תחנות במרחקים שווים זו מזו; התחנה הראשונה מסומנת בקצה החיצוני והתחנה האחרונה (ה-25) בקצה הפנימי של הספירלה. שני שחקנים משחקים אחד נגד השני. כל שחקן בתורו מקדם את הכלי בתחנה אחת לכל הפחות ובשש תחנות לכל היותר. השחקן שמציב את הכלי בתחנה האחרונה מנצח את המשחק. מהי האסטרטגיה לניצחון במשחק? האם כדאי להיות השחקן הפותח? מהי האסטרטגיה לניצחון במשחק שבו N תחנות? כתבו תכנית המקבלת כקלט את מספר התחנות N (מס' שלם בין 10 ל-1000), מחליטה האם להיות השחקן הפותח, ומשחקת מול המשתמש כך שתנצח תמיד.

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

תרגיל הנח כי כל המשתנים בקוד הם מטיפוס שלם. לפניך קטע קוד: הנח כי כל המשתנים בקוד הם מטיפוס שלם. מהי סיבוכיות זמן הריצה של קטע הקוד הנתון כפונקציה של n? Θ(n · logn) Θ(n2) Θ(n) אף תשובה אינה נכונה a = n*n; while (a > n) { n += 2; a -= 4; }

תרגיל (אביב תשס"ד) לפניך קטע קוד: הנח כי כל המשתנים בקוד הם מטיפוס שלם. מהי סיבוכיות זמן הריצה של קטע הקוד הנתון כפונקציה של n? O(n) O(n2) O(n · logn) O(1) x = n; a = 0; while (x > 1) { x = x – n/5; for (i = 1; i <= x; i++) a++; }

תרגיל (אביב תשס"ג) לפניך קטע קוד: נוסף על קטע הקוד נתון: S אינו משנה את הערכים של: y ,x ו-n. S הוא משפט פשוט, והזמן הדרוש לביצועו הוא Θ(1). מהי סיבוכיות זמן הריצה של קטע הקוד הנתון כפונקציה של n? Θ(n · logn) Θ(logn) Θ(n) Θ(n + logn) y = 2; while (y < n) { y = y + n/5; x = 1; while (x <= n) { x = x * 2; S; }

תזכורת – סדרה הנדסית כזכור, סדרה הנדסית (geometric sequence), היא סדרת מספרים שבה היחס בין כל שני מספרים עוקבים הוא קבוע. למשל, הסדרות הבאות הן סדרות הנדסיות: ... , 864 , 144 , 24 , 4 ... 264- , 64 , -16 , 4 , 1- ... , 0.3125 , 0.625, 1.25 , 2.5 , 5 , 10 את האיבר הראשון בסדרה מקובל לסמן ב- a1 . את היחס הקבוע בין שני איברים עוקבים בסדרה מקובל לסמן ב- q . הנוסחא לאיבר הכללי בסדרה (האיבר שנמצא במקום ה-n-י) היא: an= a1 · qn-1

תזכורת – סדרה הנדסית הנוסחא לסכום n האיברים הראשונים של סדרה הנדסית היא: אם -1 < q < 1 , אז סכום אינסוף איברי הסדרה הוא מספר סופי. לסדרה כזו קוראים סדרה הנדסית אינסופית מתכנסת. סכומה נתון על-ידי הנוסחא:

תרגיל (אביב תשס"ב) נתון קטע הקוד הזה: נוסף על קטע הקוד נתון: תרגיל (אביב תשס"ב) נתון קטע הקוד הזה: נוסף על קטע הקוד נתון: S אינו משנה את הערכים של: k, i ו-n. S הוא משפט פשוט והזמן הדרוש לביצועו הוא O(1). מהי סיבוכיות זמן הריצה של קטע הקוד הנתון כפונקציה של n? Θ(n) Θ(n · logn) Θ(n2/2) אף תשובה אינה נכונה i = n; while (i >= 1) { for (k = 1; k <= i; k++) S; i = i / 2; }

תרגיל (אביב תשס"ה) לפניך קטע קוד: הנח כי כל המשתנים בקוד הם מטיפוס שלם. מהי סיבוכיות זמן הריצה של קטע הקוד הנתון כפונקציה של n? Θ(n) Θ(n2) Θ(n · logn) Θ(1) for (i = 1; i <= n; i++) y = 1/i; x = n; while (x > 0) x = x – y;

מהי סיבוכיות זמן הריצה של קטע הקוד? לפניך קטע קוד: מהי סיבוכיות זמן הריצה של קטע הקוד? x = 2; while (x < n) x = x * x;

בסוף ביצוע הלולאה מתקיים לכן, סיבוכיות זמן הריצה היא Θ(loglogn).

לשם השוואה: f(n) = n g(n) = log2(n) h(n) = log2(log2(n))

תרגיל (אביב תשס"ב) נתון קטע הקוד הזה: נוסף על קטע הקוד נתון: S אינו משנה את הערכים של: a ,x ו-n. S הוא משפט פשוט, והזמן הדרוש לביצועו הוא O(1). מהי סיבוכיות זמן הריצה של קטע הקוד הנתון כפונקציה של n? O(n · logn) O(loglogn) O(n/2 · loglogn) אף תשובה אינה נכונה a = 2; while (a <= n) { x = 1; while (x < n) { x = x + n/10; S; } a = a * a;

תרגיל (אביב תשס"ד) לפניך קטע קוד: נוסף על קטע הקוד נתון: S הוא משפט פשוט, והזמן הדרוש לביצועו הוא Θ(1). S אינו משנה את הערכים של: k, a, n ו-b. כל המשתנים בקטע הקוד הם מטיפוס שלם. מהי סיבוכיות זמן הריצה של קטע הקוד הנתון כפונקציה של n? Θ(n · log2n) Θ((n · logn) · loglogn) a = 2; while (a <= n) { for (k = 1; k <= n; k++) { b = n; while (b > 1) { S; b = b / 2; } a = a * a * a; . Θ(n · logn) Θ(n2 · logn)

חיפוש לינארי (Linear Search) ברצוננו לכתוב אלגוריתם המקבל מערך של מספרים שלמים, את גודלו n, ומס' שלם נוסף num. המטרה היא לבדוק האם הערך num מופיע במערך, ולהחזיר את האינדקס שלו במידה והוא מופיע, ואת הערך 1- ובמידה ולא. האלגוריתם הפשוט ביותר לפתרון הבעיה, מתבסס על סריקת המערך בצורה סדרתית (לינארית), מהתא הראשון ועד לסוף המערך. אם תוך כדי הסריקה נפגוש את הערך המבוקש – נחזיר את האינדקס שלו. אם הגענו לסוף המערך, וטרם מצאנו את הערך המבוקש – סימן שהוא לא מופיע במערך, ונחזיר את הערך 1-.

חיפוש לינארי (Linear Search) האלגוריתם לחיפוש לינארי יראה כך: עבור i מ-0 עד n-1, בצע: אם array[i] == num, אזי: החזר i החזר -1 נחשב את סיבוכיות זמן הריצה של האלגוריתם: האלגוריתם עובר תא-תא במערך, ובמקרה הגרוע ביותר (כשהערך המבוקש לא נמצא במערך כלל, או כאשר הוא נמצא במקום האחרון), הוא סורק את כולו. לכן, סיבוכיות זמן הריצה של האלגוריתם היא לינארית כגודל הקלט.

חיפוש בינארי (Binary Search) הרעיון האלגוריתמי: נשתמש ב-high ו-low להכיל את האינדקס הגבוה ביותר והנמוך ביותר בהם אנו מטפלים כרגע. נציב ב-middle את הממוצע החשבוני שלהם (אמצע המערך). אם הערך המבוקש גדול מהאיבר במקום middle, אז במחזור הבא נסתכל רק על תת-המערך [middle+1…high]. אם הוא קטן מהאיבר במקום middle, אז נסתכל רק על תת-המערך [low …middle-1]. אם הערך המבוקש שווה לאיבר במקום middle, אז סיימנו. האלגוריתם לחיפוש בינארי מסתכל בהתחלה על המערך כולו, אחר-כך על חצי ממנו, רבע ממנו, וכו'.

חיפוש בינארי (Binary Search) אבל מה קורה אם הערך המבוקש num אינו נמצא כלל במערך? האלגוריתם לחיפוש בינארי יראה כך: low  0 high  n-1 found  false כל עוד לא found, בצע: middle  (high+low)/2 אם array[middle] > num, אזי: low  middle+1 אחרת: high  middle-1 found  true החזר middle

חיפוש בינארי (Binary Search) האלגוריתם המתוקן לחיפוש בינארי יראה כך: low  0 high  n-1 כל עוד low <= high, בצע: middle  (high+low)/2 אם array[middle] > num, אזי: low  middle+1 אחרת: high  middle-1 החזר middle החזר -1

חיפוש בינארי (Binary Search) שימו לב שהאלגוריתם לחיפוש בינארי עובד רק על מערכים ממוינים (בניגוד לחיפוש הסדרתי, שפועל על כל מערך), ולכן חובה למיין קודם את המערך. מהי סיבוכיות זמן הריצה של החיפוש הבינארי? בכל מחזור קטן גודל תת-המערך פי 2, עד שנשארים (במקרה הגרוע ביותר) עם תא אחד בודד. לכן, עבור מערך בגודל n, נבחן מערכים בגודל n, n/2, n/4, n/8, n/16, ... , 1. מתקיימת המשוואה: 1=n/2k שהפתרון שלה הוא k=log2(n). כלומר – האלגוריתם יבצע לכל היותר log2(n) איטרציות, לכן סדר הגודל שלו הוא לוגריתמי (שזה יעיל יותר מלינארי).

מיון מיון מערך (Sorting an array) היא פעולה במהלכה לוקחים מערך המכיל איברים, ומארגנים אותם בסדר חדש, כך שאיברי המערך החדש יהוו סדרה מונוטונית (עולה או יורדת). לדוגמא, אם נקבל את המערך הבא: אז לאחר פעולת מיון, הוא יראה כך: 7 8 20 4 1 15 18 3 1 3 4 7 8 15 18 20

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

מיון בחירה (Selection Sort) הרעיון האלגוריתמי: נמצא את האיבר הקטן ביותר במערך, ונשים אותו במקום הראשון; נמצא את האיבר הקטן ביותר ביתר המערך (כל האיברים, למעט הראשון) ונשים אותו במקום השני; נמצא את האיבר הקטן ביותר ביתר המערך (כל האיברים, למעט הראשון והשני) ונשים אותו במקום השלישי, וכך הלאה. האלגוריתם יסתיים, כאשר אין יותר איברים ביתר המערך (כלומר, כאשר שמנו כבר איבר במקום האחרון).

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

מיון בחירה (Selection Sort) מהן שתי הפעולות שחוזרות על עצמן בכל איטרציה (מחזור לולאה)? מציאת האיבר הקטן ביותר בתחום האדום. ביצוע פעולת החלפה בינו לבין האיבר הראשון של התחום האדום (משבצת זו עכשיו הופכת להיות ירוקה). איך נראה האזור האדום ואיך נראה האזור הירוק? לפני ביצוע הלולאה : האדום הוא n-1..0 והירוק ריק בסיום האיטרציה i = 0 : האדום הוא 1..n-1 והירוק הוא 0..0 בסיום האיטרציה i = 1 : האדום הוא 2..n-1 והירוק הוא 0..1 בסיום האיטרציה i = 2 : האדום הוא 3..n-1 והירוק הוא 0..2 ... בסיום האיטרציה i = n-1 : האדום הוא ריק והירוק הוא 0..n-1 ננסה לחשוב: מה יהיה התחום האדום ומה יהיה התחום הירוק בסוף כל איטרציה? בסיום איטרציה i : התחום הירוק הוא 0..i התחום האדום הוא i+1..n-1

מיון בחירה (Selection Sort) אלגוריתם למיון בחירה: עבור i מ- עד בצע מצא את הערך המינימלי בתחום a[ ]…a[ ] שמור את האינדקס שלו ב-min_index החלף את האיבר a[ ] עם האיבר a[min_index] השלימו את הביטויים החסרים באלגוריתם. כעת ניגש לכתוב תכנית מחשב בשפת C, המיישמת את האלגוריתם למיון בחירה.

מיון בחירה (Selection Sort) ראינו ששתי הפעולות שחוזרות על עצמן בכל איטרציה (מחזור לולאה) הן: מציאת האיבר הקטן ביותר בתחום האדום. ביצוע פעולת החלפה בינו לבין האיבר הראשון של התחום האדום (משבצת זו עכשיו הופכת להיות ירוקה). נכתוב שתי פונקציות, אחת עבור כל פעולה: פונקציה בשם find_min שתקבל כפרמטר את המערך, את גודלו, וכן אינדקס המציין איפה מתחיל התחום האדום. הפונקציה תחזיר את האינדקס של האיבר המינימלי בתחום האדום. פונקציה בשם swap שתקבל כפרמטרים שני איברים ותחליף ביניהם. איך יראו הכותרות של שתי פונקציות אלו בשפת C?

מיון בחירה (Selection Sort) כותרת הפונקציה הראשונה תהיה: int find_min (int a[], int start, int n) הפונקציה תקבל מערך a של מס' שלמים (לאו דווקא חיוביים), שגודלו n. המס' השלם start הוא אינדקס במערך, והוא מקיים < start < n0 . הפונקציה תחזיר את האינדקס של האיבר המינימלי במערך, בתחום שבין start ל n-1. הפונקציה השנייה כותרתה תהיה: void swap (int *a, int *b) הפונקציה תקבל מצביעים לשני משתנים מטיפוס שלם, ותבצע החלפה ביניהם.

מיון בחירה (Selection Sort) void selection_sort (int a[], int n) /* בעזרת מיון בחירה n שגודלו a הפרוצדורה ממיינת את המערך*/ { int i; /* מונה לולאה */ int min_index; /* אינדקס איבר מינימלי מהתחום הלא-הממוין */ for ( ) min_index = ; swap( ); /* i+1..n-1 ולא ממוין בתחום 0..i המערך ממוין בתחום */ /* 0..i גדולים מהאיברים בתחום i+1..n-1 האיברים בתחום*/ } i = 0; i < n-1; i++ find_min(a,i,n) &a[i],&a[min_index] הערה כמו זו המופיעה בסוף הלולאה נקראת שמורת לולאה (loop invariant). היא מייצגת תכונה הנשמרת בסיום ביצוע כל מחזור של הלולאה.

מיון בחירה (Selection Sort) ננתח את סיבוכיות האלגוריתם למיון בחירה. בעצם מדובר פה בלולאה מקוננת, כי הפונקציה find_min שאותה אנחנו מזמנים בתוך הלולאה, בעצמה מכילה לולאה. כמה צעדים מתבצעים בסך הכול באלגוריתם? כאשר i = 0, הלולאה שבתוך find_min מתבצעת n-1 פעמים. כאשר i = 1, הלולאה שבתוך find_min מתבצעת n-2 פעמים. כאשר i = 2, הלולאה שבתוך find_min מתבצעת n-3 פעמים. ... כאשר i = n-2, הלולאה שבתוך find_min מתבצעת פעם אחת. לפי הנוסחה לסכום איברי סדרה חשבונית, נקבל: 1 + 2 + 3 + … + (n-3) + (n-2) + (n-1) = n*(n-1)/2 = Θ(n2) כלומר, מיון בחירה של n איברים, דורש בערך n2/2 צעדים. מספר זה גדל בקצב גבוה, ומגיע לחצי מיליון עבור מערך בן 1000 איברים!