‫מבנה נתונים‬

‫מצגת ‪ – 5‬סיבוכיות ושיפור יעילות אלגוריתם‬

‫‪ ‬מבוא לסיבוכיות‬
‫‪ ‬סיבוכיות זמן קבוע )‪O(1‬‬
‫‪ ‬סיבוכיות זמן לינארי ‪O (n) -‬‬
‫‪ ‬סיבוכיות ריבועית‪/‬פולינומיאלית (‪O (np‬‬
‫‪ ‬סיבוכיות לוגוריתמית)‪O(log n‬‬
‫‪ ‬סיכום סדרי גודל‬
‫‪ ‬סיבוכיות )‪O(n*m‬‬

‫‪1‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫א‪ .‬מבוא לסיבוכיות‬

‫‪ ‬ניתוח סיבוכיות אלגוריתם עונה על השאלה כמה משאבים‪ ,‬כגון שטח או זמן‪,‬‬
‫אלגוריתם צורך‪.‬‬
‫‪ ‬ככל שהאלגוריתם לוקח פחות זמן‪ ,‬כך יותר יעיל‪.‬‬

‫סיבוכיות ‪ O‬גדולה ‪" -‬חסם עליון"‬

‫‪ ‬סימון ‪ O‬גדולה ‪ -‬נותן את התרחיש הגרוע ביותר של קצב הצמיחה של‬

‫אלגוריתם‪.‬‬
‫‪ ‬אך הוא יכול לצמוח לאט יותר‪.‬‬
‫‪ ‬המפתח להבנת ‪ O‬הוא הבנת שיעור הזמן הנדרש לאופן גידול ביחס לקלט‪.‬‬

‫‪ ‬לא אכפת לנו מהפרטים של זמן הריצה‪ ,‬אלא לאופן גידול ביחס לקלט‪.‬‬

‫‪2‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫ב‪ .‬סיבוכיות זמן קבוע )‪O(1‬‬

‫‪ ‬לוקח מקום ללא קשר לגודל הקלט‪.‬‬

‫‪ ‬דוגמה (קלט הוא ‪:)n‬‬

‫;)‪Console.WriteLine ("Your input is: " + n‬‬

‫‪ ‬לא משנה מה ערך ‪ ,n‬לקוד זו לוקח זמן קבוע להפעל ‪ -‬לא תלוי בגודל של ‪.n‬‬
‫‪ ‬דוגמה (קלט הוא ‪:)n‬‬

‫;)‪Console.WriteLine("Your input is: " + n‬‬

‫;)‪Console.WriteLine("Your input is: " + n‬‬
‫;)‪Console.WriteLine("Your input is: " + n‬‬

‫‪ ‬לא משנה מה ערך ‪ ,n‬לקוד זו לוקח זמן קבוע להפעלה‪.‬‬

‫‪ ‬אנו מציינים אלגוריתמים של זמן קבוע )‪.O (1‬‬
‫‪ ‬שים לב ש‪ O (2), O (3) -‬או אפילו )‪ O (1000‬פירושו אותו דבר‪.‬‬

‫‪3‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫סיבוכיות זמן לינארי ‪O (n) -‬‬ ‫ג‪.‬‬

‫‪ ‬לוקח מקום ביחס ישיר לגודל הקלט‬

‫‪ ‬אם אנו אומרים שמספר פעולות גדלות באופן לינארי‪ ,‬אנו מתכוונים שהן גדלות‬
‫ביחס ישיר לגודל הקלט‪.‬‬
‫‪ ‬דוגמה‪ ,‬לולאת ‪( for‬קלט הוא ‪:)n‬‬

‫)‪for (int i = 0; i < n; i++‬‬

‫;)‪Console.WriteLine(i‬‬

‫‪ ‬לולאה פועלת ‪ n‬פעמים ‪ -‬האלגוריתם יגדל באופן לינארי עם גודל הקלט שלו‪.‬‬
‫‪ ‬אנו מעדיפים זמן ריצה של ‪ n‬מ‪ ,1000n -‬אך שניהם עדיין אלגוריתמים ‪ -‬הם‬
‫גדלים ישירות ביחס לגודל הקלט שלהם‪.‬‬
‫‪ ‬דוגמה‪:‬‬

‫)‪for (int i = 0; i < n; i++‬‬

‫{‬
‫;)‪Console.WriteLine( i‬‬
‫;)‪Console.WriteLine( i‬‬
‫;)‪Console.WriteLine( i‬‬
‫}‬
‫‪ ‬לולאה פועלת ‪ n‬פעמים‪ ,‬זמן הריצה עדיין יהיה ליניארי‪.‬‬
‫‪ ‬אנו מציינים אלגוריתמים ליניאריים )‪.O (n‬‬
‫‪ O (2n+1) ‬זהה ל‪ ,O (n) -‬שכן סיבוכיות ‪ O‬מתייחסת לאופן גידול ביחס לקלט‪.‬‬

‫‪4‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫‪ ‬מה מספר הפעולות המבוצעות ומה הסיבוכיות?‬

‫)‪for (int j = 0; j < n; j++‬‬

‫;)"*"(‪Console.WriteLine‬‬

‫‪ ‬מה מספר הפעולות המבוצעות ומה הסיבוכיות?‬

‫)‪for (int i = 0; i < 10; i++‬‬

‫;)"*"(‪Console.WriteLine‬‬

‫‪ ‬מה מספר הפעולות המבוצעות ומה הסיבוכיות?‬

‫)‪for (int i = 0; i < n; i++‬‬

‫)‪for (int j = 0; j < 4; j++‬‬
‫;)"*"(‪Console.WriteLine‬‬

‫‪5‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫סיבוכיות פולינומיאלית\ריבועית (‪O (nk‬‬ ‫ד‪.‬‬

‫‪ ‬לוקח מקום הגדל באופן פרופורציונאלי לריבוע גודל הקלט‪.‬‬

‫‪ ‬המונח פולינום הוא מונח כללי המכיל פונקציות ריבועיות‪.‬‬
‫‪ ‬מה שחשוב לדעת הוא ש‪ O (n2) -‬מהיר יותר מ‪ O (n3) -‬המהיר יותר‬
‫מ‪ O (n4) -‬וכו '‪.‬‬
‫‪ ‬דוגמה‪:‬‬

‫)‪for (int i = 0; i < n; i++‬‬

‫)‪for (int j = 0; j < n; j++‬‬
‫;)"*"(‪Console.WriteLine‬‬

‫‪ ‬סיבוכיות‪O (n2) :‬‬

‫‪6‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫סכום טור המספרים הטבעיים‬
‫‪ ‬טור המספרים הטבעיים הוא תוצאת החיבור של סדרת המספרים‪ ,‬מ‪ 1-‬ועד ‪.n‬‬
‫‪]1+2+3+…+n[ ‬‬
‫‪ ‬דוגמה‪:‬‬

‫;‪int sum=0‬‬
‫)‪for (int i = 1; i <= n; i++‬‬
‫{‬
‫;‪sum = 0‬‬
‫)‪for (int j = 1; j <= i; j++‬‬
‫;‪sum += j‬‬
‫}‬

‫‪ ‬סיבוכיות‪O(n^2) :‬‬

‫חיפוש איבר במערך בעל ‪ n‬אלמנטים‬

‫‪ ‬באלגוריתם זה‪ ,‬בכל איטרציה בודקים האם מספר המטרה הוא המספר אותו‬
‫אנו מחפשים‪.‬‬
‫‪ ‬המקרה הגרוע ביותר לאלגוריתם זה יהיה אם האלמנט שאנו מחפשים הוא‬
‫האלמנט האחרון במערך‪.‬‬
‫‪ ‬במקרה זה‪ ,‬נחזור על ‪ n‬פעמים לפני שנמצא את האלמנט‪.‬‬
‫‪ ‬מכאן שסיבוכיות הזמן של חיפוש לינארי היא )‪.O (n‬‬

‫‪7‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫ה‪ .‬סיבוכיות לוגוריתמית )‪O(log n‬‬

‫חיפוש בינארי במערך ממוין‬

‫‪ ‬חיפוש בינארי או לוגריתמי הוא נפוץ ביותר בגלל זמן החיפוש המהיר שלו‪.‬‬
‫‪ ‬הוא מחלק את אוסף הקלט לחצאים שווים‪ ,‬ובכל איטרציה משווה את מספר‬
‫המטרה עם המספר באמצע‪.‬‬
‫‪ ‬אם האלמנט נמצא‪ ,‬החיפוש מסתיים‪.‬‬
‫‪ ‬אחרת‪ ,‬אנו ממשיכים לחפש את האלמנט על ידי חלוקה ובחירה של המחיצה‬
‫המתאימה של המערך‪ ,‬בהתבסס על אם רכיב המטרה קטן או גדול מהאלמנט‬
‫האמצעי‪.‬‬

‫‪ ‬לדוגמה‪ ,‬נתון‪:‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪9‬‬

‫‪ ‬חיפוש בינארי‪:‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪9‬‬ ‫‪6>4‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪9‬‬ ‫‪6<7‬‬

‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪9‬‬ ‫‪6=6‬‬

‫‪8‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫סיבוכיות לוגוריתמית )‪O(log n‬‬
‫‪ ‬סיבוכיות זמן לוגריתמית יותר מסובכת לדמיין‪.‬‬
‫‪ ‬חיפוש בינארי מבוסס על כך שבכל צעד מקטינים את תחום החיפוש בחצי‪.‬‬
‫‪ ‬נחשב כמה פעמים יש לחלק (‪ K‬פעמים)‪.‬‬
‫‪ ‬במקרה הגרוע‪ ,‬נחלק ונקטין את המערך עד אשר גודלו יהיה ‪.1‬‬
‫‪ ‬ה‪ log-‬היא בבסיס ‪.2‬‬
‫‪ ‬סיבוכיות הזמן הזו היא שיפור ניכר מסיבוכיות הזמן )‪ O (N‬של חיפוש לינארי‪.‬‬

‫‪ ‬סיבוכיות לוגוריתמית מול ליניארית‬

‫‪ ‬דוגמה ‪:1‬‬

‫)‪for (; n > 1; n = n / 2‬‬

‫;)‪Console.WriteLine(n‬‬

‫‪ ‬דוגמה ‪:2‬‬

‫)‪for (int i = 1; i < n; i = i * 2‬‬

‫;)‪Console.WriteLine(i‬‬
‫‪9‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫סיבוכיות לוגוריתמית)‪O(n * log n‬‬
‫‪ n log n‬הוא המחלקה הבאה של אלגוריתמים‪.‬‬ ‫‪‬‬
‫‪ ‬זמן הריצה גדל ביחס ל‪ n log n -‬של הקלט‪.‬‬
‫‪ ‬דוגמה‪:‬‬

‫)‪for (int i = 1; i <= n; i++‬‬

‫)‪for (int j = 1; j < n; j = j * 2‬‬
‫;)"*"(‪Console.WriteLine‬‬

‫‪11‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬
 ‫סיכום סדרי גודל ‪ O‬גדולה‬ ‫ו‪.‬‬

‫סימון‬ ‫סדר גודל‬

‫)‪O(1‬‬ ‫קבוע‬
‫)‪O(log n‬‬ ‫לוגוריתמי‬
‫)‪O(n‬‬ ‫ליניארי‬
‫)‪O(n*log n‬‬ ‫ליניארי‪-‬לוגוריתמי‬
‫(‪O (nk‬‬ ‫פולינומיאלי‬
‫(‪O (2n‬‬ ‫מעריכי‬
‫(!‪O (n‬‬ ‫עצרת‬

‫‪11‬‬
‫נכתב ע"י ניצן דולינסקי ‪Ⓒ‬‬
‫אין לשכפל ‪ /‬להעתיק ללא אישור‬