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

שעור ראשון מבנה נתונים הוא דגם המגדיר את היחסים בין הנתונים ואת הפעולות המבוצעות עליהם. במציאות משתמשים במספר מבני נתונים. למשל, איברים המסודרים בתור )Queue( לפי סדר הגעתם. האיבר שהיגיע ראשון נשלף ראשון Out(.) FIFO: First In First דוגמה אחרת היא מחסנית )Stack( האיבר שהגיע אחרון נשלף ראשון Out( (. LIFO: Last In First המבנה הפשוט ביותר המוכר לנו הוא מערך. אך לעיתים אחסון נתונים במערך מסרבל את הבעיה ואילו שימוש במבנה נתונים מתאים פותר אותה. לדוגמה, ניהול מעקב אחר התנועה ברשת כבישים עירונית אם נאחסן את הכבישים במערך, לא יהיה לנו כל מידע על היחסים בין הכבישים, שכן במערך כל איבר מתייחס, לכל היותר, לזה שלפניו ולזה שאחריו, ואילו במערכת כבישים כל כביש יכול להתחבר למספר כבישים. לשם כך נצטרך להשתמש במבנה נתונים יותר מורכב שישקף את המציות. בעת טיפול בנתונים אנו נדרשים לשלוש פעולות עיקריות: החסנת איבר הוצאת איבר חיפוש איבר... אפשר לבצע פעולות אלו בשיטות שונות. שאיפתנו היא לבצע את הפעולות ביעילות הגבוהה ביותר, דהיינו במספר קטן ככל האפשר של צעדים. מדידת היעילות נקראת סיבוכיות.)complexity( Abstract Data Type ADT אחד מהדברים החשובים ביותר הוא שהמבנה יהיה מודולארי. פעולות המוגדרות על מבנה הנתונים חשופות למשתמש בו. למשל, נכנה מבנה נתונים.Vector כל תכנית שזקוקה למבנה מדגם זה צריכה להגדיר משתנה מטיפוס זה: Vector v = new Vector(); ועל מנת להכניס איבר חדש אל התכנית להפעיל מתודה insert על משתנה v: v.insert(newitem) על מנת לצור מבנה נתונים מבנה נתונים מודולארי יש לבצע את שלושת השלבים הבאים: תיאור מבנה באופן אבסטרקטי. שבלב זה יש להגדיר את מערכת הקשרים בין הנתונים ואת הפעולות שיש לבצע על הנתונים. שלב זה מכונה.Abstract Data Type ADT הגדרה זו מנותקת ממימוש בשפה. תיאור האלגוריתמים של פעולות המבנה. שבלב זה, לאחר שמגדירים את ה- ADT, מגדירים כיצד מתבצעים האלגוריתמים של פעולות מבנה הנתונים. הגדרת האלגוריתמים, גם היא, עדיין מנותקת משפה ספציפית ומוגדרים כפד ו-קוד או כתרשים זרימה. בשלב זה מוגדר למעשה מבנה הנתונים. מימוש מבנה בשפה. המעבר משלב השני לשלב שלישי משתנה בהתאם לשפה, משום שבכל שפה ממשים אלגוריתמים באופן שונה....

אלגוריתמים כבסיס לתוכנה. אלגוריתם הוא דרך שיטתית )כלומר כזו שצעדיה מוגדרים היטב( לביצועה של משימה מסוימת במספר סופי של צעדים. קיימת חשיבות גדולה ליעילות של האלגוריתמים. למשל אם נכתוב אלגוריתם למציאת האיבר הגדול ביותר במערך בעל N איברים, נשתמש באחת משתי השיטות הבאות: להשוות כל מספר לכל המספרים האחרים וכך למצוא את הגדול מביניהם. להניח שהמספר הראשון הוא הגדול ביותר, ולהשוותו לבאים אחריו. אם נמצא מספר גדול ממנו, יש לשנות את ההנחה, ולהשוות את כל הבאים אחריו למספר החדש... באלגוריתם הראשון יש לרוץ על המערך N*N פעמים, ואילו לפי האלגוריתם השני יש לרוץ על המערך פעם אחד בלבד, כלומר סה"כ N פעמים. יעילות האלגוריתם נקבעת על-פי מספר הצעדים שמתבצעים בו ולא על פי סוג הנתונים המאוחסנים במערך או סוג המחשב. סיבוכיות היא סדר-גודל של מספר הצעדים הנדרשים לביצוע האלגוריתם. סיבוכיות מסומנת באות O. סיבוכיות )complexity( O)( כיצד נמדוד את הסיבוכיות? סיבוכיות היא פונקציה של מספר האיברים המאוחסנים. כל פעולה המתבצעת מספר קבוע של פעמים תהיה בעלת סיבוכיות של.O)( היא בעלת סיבוכיות size = 0000 למשל פעולת השמה וכן פעולת החלפה: public static void swap(int [] array, int i, int j){ int temp = array[i]; array[i] = array[j]; array[j] = temp; היא בעלת סיבוכיות )(O, למרות שמתבצעות כאן החלפות. הכלל הוא: ) O) =)מספר קבוע( O הדפסת מערך בעל N איברים היא פעולה בעלת סיבוכיות.O)N( אם בנוסף אנו כופלים כל איבר המערך ב- לפני שמדפיסים אותו אנו מבצעים בעצם *N פעולות. אולם כיוון שסיבוכיות נמדדת בסדרי גודל, המספרים הקבועים אינם משפיעים על הסיבוכיות ולכן גם במקרה השני הסיבוכיות היא.O)N( הכלל הוא: ) O)N =מספר קבוע* ) O)N =)מספר קבוע* O)N סיבוכיות של אלגוריתם נקבעת על-פי הסיבוכיות הגבוהה ביותר של תת-האלגוריתמים. למשל, בחישוב הערך הממוצעת של איברי המערך: int sum = 0; // O() for(int i=0;i<arr.length;i=i+) {; // O(n),n = arr.length sum = sum + arr[i]; double average = (double)sum/arr.length; // O() System.out.println("average "+average); // O()

הסיבוכיות של אלגוריתם זה היא O(n) O(n)+ +()O +()O =()O סוגי סיבוכיות: במקרים רבים באלגוריתמים הסיבוכיות שתושג בפועל תלויה באופן שבו מסודרים האיברים. למשל, באלגוריתם למציאת איבר במערך, יש לעבור על כל המערך ובכל איטרציה להשוות את האיבר ולבחון האם מצאנו אותו. באלגוריתם כזה נבחין בין שלושה מקרים: המקרה הטוב case( )best שבו האיבר נמצא במקום הראשון. הסיבוכיות היא ()O. המקרה הגרוע case( )worst שבו האיבר נמצא במקום האחרון. הסיבוכיות היא.O(n) המקרה הממוצע case( )average שבו האיבר נמצא באמצע, ואז הסיבוכיות היא. זהה ל-( O(n O(n/) מכיוון ש-,O(n) דוגמאות לסיבוכיות: O(0) = O() O(n + 4) = O(n) O(n +n+4) = O(n ) O(4n +00n) = O(n ) O(log n) = (log n) O(4 n ) = O(4 n )... מיון: דיון \ אלגוריתם ראשוני מיון היא האחת הפעולות הנפוצות ביותר בתוכנה, ישנם אלגוריתמים רבים למיון. הצעה לאלגוריתם נאיבי )פשוט( למיון Sort( )Selection :. צור מערך והכנס עליו את האיברים שיש למיין. כל עוד המערך איננו ריק:. מצא את מיקום של האיבר הקטן ביותר במערך (minindex). שים את איבר זה 'בצד'. חזור ל. ננסה לממש כל סעיף באלגוריתם בעזרת פונקציה: חיפוש את המיקום של הערך הקטן ביותר במערך: 'הוצאת' האיבר הקטן ביותר במערך )שים 'בצד'( מסגרת כללית לפונקצית המיון ננסה לממש כל סעיף באלגוריתם בעזרת פונקציה: חיפוש הערך הקטן )אינדקס( ביותר במערך:

דוגמה ל- Sort : Selection Selection Sort pseudo-code Selection-Sort(A) for i= to length(a) minindex = Smallest-Index(i, A) A[i]A[minIndex] end-for end-selection-sort Smallest-Index(start, A) minindex = start for i=start to length(a) if (A[i]<A[minIndex]) then minindex = i end-if end-for return minindex end-smallestindex סיבוכיות : SelectionSort באלגוריתם זה אנו עוברים בלולאה חיצונית על כל איברי המערך באופן סדרתי.O)n( בתוך לולאה זו אנו עוברים שוב על המערך באופן סדרתי, אך הפעם בכל לולאה מספר איברי המערך קטן באחד. לפיכך מספר פעולות הוא: 4

(n -) + (n - ) +... += n(n-), n O O סיבוכיות של אלגוריתם נקבעת על-פי סדר גודל, לכך סה"כ הסיבוכיות היא: ) O(n מיון בועות Bubble Sort מיון זה, דומה מאוד לקודמו, בכך שבכל איטרציה אנו מגדילים את השמורה הממוינת. אנו משווים בין איברים-שכנים, ואם הראשון גדול מהבא מחליפים ביניהם. כך בכל איטרציה אנו "מבעבעים" את האיבר הגדול כלפי ממעלה. לכן מיון זה דורש הרבה החלפות, שלו כמו במיון הקודם של,Selection Sort שבל איטרציה החלפנו לכל היותר פעם אחד. דוגמה: איטרציה Bubble Sort pseudo- code Bubble-Sort(A) flag = true i= while (i<=length(a) and flag=true) flag = false for j= to length(a)-i if (A[j]>A[j+]) then flag = true A[j]A[j+] end-if end-for i = i+ end-while end-bubble-sort סיבוכיות : BubbleSort באלגוריתם זה אנו עוברים בלולאה חיצונית על כל איברי המערך באופן סדרתי.O)n( בתוך לולאה זו אנו עוברים שוב על המערך באופן סדרתי, אך הפעם בכל לולאה מספר איברי המערך קטן באחד. לפיכך מספר פעולות הוא:

(n-)+(n-)+... += n(n-), n O O סיבוכיות של אלגוריתם נקבעת על-פי סדר גודל, לכך סה"כ הסיבוכיות היא: ) O(n מיון הכנסה Insertion Sort מיון זה, דומה מאוד לקודמיו, עובר בלולאה כפולה על המערך. אולם כאן כל איבר בתורו עובר למקומו הראלי במערך על-ידי החלפתו באיבר הקודם לו, עד שמגיעה לאיבר הקטן ממנו. איטרציה ראשונה: איטרציה שניה: Insertion Sort pseudo-code Insertion-Sort(A) for i= to length(a) j = i while(j> and A[j-]>A[j]) A[j-]A[j] j = j- end-while end-for end Insertion-Sort סיבוכיות : InsertionSort באלגוריתם זה אנו עוברים בלולאה חיצונית על כל איברי המערך באופן סדרתי.O)n( בתוך לולאה זו אנו עוברים שוב על המערך באופן סדרתי, אך הפעם בכל לולאה מספר איברי המערך קטן באחד. לפיכך מספר פעולות הוא: (n -) + (n - ) +... += n(n-), n O O

סיבוכיות של אלגוריתם נקבעת על-פי סדר גודל, לכך סה"כ הסיבוכיות היא: O(n ) שים לב, הסיבוכיות במיון זה שווה לשני המיונים הקודמים, אולם במיון זה, ייתכן שנחסוך לולאות רבות בשל הגדרת התנאי כל עוד האיבר קטן מקודמו. Insertion Sort public static void insertionsort(int[] arr){ for (int i=; i <arr.length; i++){ int j = i; while (j>0 && arr[j]<arr[j-]){ swap(arr, j, j-); j = j-; פלט: הזמן נמדד בשניות (second( השוואה בין שלושה המיונים: מיון מערך של מספרים אקראיים )בין 0 ל- ) בן 0000 איברים: size = 0000 Java Sort time = 0.004 seconds, is sorted? true bubblesort time = 0. seconds, is sorted? true selectionsort time = 0.7 seconds, is sorted? true insertionsort time = 0. seconds, is sorted? true השוואה בין שלושה המיונים: מיון מערך של מספרים אקראיים )בין 0 ל- ) בן 00000 איברים: 8.78) שניות) = 878 time bubblesort.) שניות) = time selectionsort.4) שניות) = 4 time insertionsort מיון מערך של מספרים שלמים בתווח ידוע Integer Sort כאשר צריך למיין מערך של מספרים שלמים איבר המערך יכול לשמש כאינדקס בתוך המערך. שלבים האלגוריתם הם: א( מחשבים איבר מקסימאלי max ואיבר מינימאלי min של המערך. ב( מגדירים מערך עזר בגודל.max-min+ מערך זה מכיל את תדירויות של כל איבר של מערך מקורי. ג( לפי ערכים של תדירויות מעדכנים את המערך המקורי. 7

public static void lineareffectivesort(int[] arr){ int min = arr[0], max = arr[0]; for (int i = ; i < arr.length; i++) { if (arr[i]>max) max = arr[i]; else if (arr[i]<min) min = arr[i]; int freq[] = new int[max-min+]; for (int i = 0; i < arr.length; i++) { freq[arr[i]-min]++; int j = 0; for (int k=0; k<freq.length; k++){ for (int i=0; i<freq[k]; i++){ arr[j++] = k+min; השוואה בין מיון של java ומיון ליניארי: מיון מערך של מספרים אקראיים )בין 0 ל- ) בן 000000 איברים: Java Sort time = 0. seconds, is sorted? true Linear Sort using minimum Memory time = 0.07 seconds, is sorted? true 8