1. בתרגול הקודם כללי הרשאות (Visibility modifiers) בהורשה – Public – Protected – private חוקי גישה לשדות ושיטות בהורשה ב -Java מחלקות אבסטרקטיות –המילה השמורה abstract –שיטות אבסטרקטיות ( ללא מימוש ) –לא ניתן ליצור מופעים –השוואה בין ממשקים למחלקות אבסטרקטיות 1

2. תרגול 12 – ( קצת על ) מבני נתונים רשימה מקושרת Iterator תור מחסנית 2

3. רשימה מקושרת (Linked List) רשימה מקושרת הינה קבוצה סדורה של אובייקטים, כאשר כל אובייקט ברשימה מכיל הצבעה לאובייקט הבא. כל אובייקט מהווה חוליה בשרשרת : - קודקוד ברשימה הינו מסוג Link - כל הרשימה נקראת LinkedList null Data Next Link 3

4. מחלקה שמייצגת חוליה Link Data Next Link 4 public class Link { private Object data; // המידע שהחוליה מכילה private Link next; // (nullמצביע לחוליה הבאה ברשימה (או ל- public Link(Object data, Link next) { this.data = data; this.next = next; } public Link(Object data) { this(data, null); } public Object getData() { return data; } public void setData(Object data) { this.data = data; } public Link getNext() { return next; } public void setNext(Link next) { this.next = next; }

5. מחלקה שמייצגת רשימה מקושרת LinkedList public class LinkedList { private Link first; public LinkedList (){ first = null; } public LinkedList (Object data){ first = new Link(data, null); }... } 5

6. מחלקה שמייצגת רשימה מקושרת LinkedList null LinkedList datanext datanext datanext first 6

7. public boolean isEmpty() { return (first == null); } נוסיף למחלקה את השיטה : נרצה לדעת האם הרשימה שלנו מכילה איברים או לא ? אז נוסיף את השיטה הבוליאנית isEmpty() אשר תחזיר true אם הרשימה ריקה, ו -false אחרת. 7

8. נוסיף למחלקה את השיטה : 8 public void addLast(Object data) { Link newLink = new Link(data, null); if (isEmpty()) { first = newLink; } else { Link linkPointer = first; while (linkPointer.getNext() != null) { linkPointer = linkPointer.getNext(); } linkPointer.setNext(newLink); } איך ניתן לבצע הכנסת איבר לסוף הרשימה במספר קבוע של פעולות? רוצים רמז? נניח שמותר לנו להוסיף שדה. איזה שדה נוסיף? לאיזו מחלקה?

9. דוגמת שימוש lst.addLast( "World!"); LinkedList lst = new LinkedList(); lst.addLast( "Hello" ); lst.addLast( "Great" ); null datanextdatanextdata next LinkedList first null 9

10. נוסיף שיטה אשר מסירה את החוליה הראשונה ברשימה ומחזירה את האובייקט המוצבע על ידה. public Object removeFirst(){ Object ans; if (isEmpty()) { ans = null; } else { ans = first.getData(); first = first.getNext(); } return ans; } נוסיף למחלקה גם את השיטה : 10

11. המשך דוגמת שימוש lst.removeFirst(); null datanextdatanextdatanext LinkedList first "Hello""Great""World!" 11

12. המשך דוגמת שימוש lst.removeFirst(); null datanextdata next LinkedList first lst.removeFirst(); "Great""World!" 12

13. המשך דוגמת שימוש lst.removeFirst(); null data next LinkedList first lst.removeFirst(); "World!" 13

14. המשך דוגמת שימוש lst.removeFirst(); null LinkedList first lst.removeFirst(); 14

15. נוסיף למחלקה LinkedList את השיטה getMiddle : 1.getMiddle - מהו האיבר האמצעי ברשימה ? - רעיונות לפתרון ? 15

16. getMiddle 16 public Object getMiddle(){ Object ans; if(isEmpty()) { ans = null; } else { Link current = first; Link jumper = first; while( (jumper != null) && (jumper.getNext() != null) ){ current = current.getNext(); jumper = jumper.getNext().getNext(); } ans = current.getData(); } return ans; } &&

17. … while( (jumper != null) && (jumper.getNext() != null) ){ current = current.getNext(); jumper = jumper.getNext().getNext(); } ans = current.getData(); … 17

18. נוסיף למחלקה LinkedList את השיטה containsCircles : 2. containsCircles - האם יש מעגלים ברשימה ? - האם עלולים להיווצר מעגלים שכאלה ? - חידה : כמה מעגלים לכל היותר יכולים להיות ברשימה מקושרת ? 18

19. 19 public boolean containsCircles() { boolean ans; if(isEmpty()) { ans = false; } else { Link current = first; Link jumper = first; boolean start = true; while(jumper != null && ( current != jumper || start) ){ start = false; current = current.getNext(); jumper = jumper.getNext(); if (jumper != null) jumper = jumper.getNext(); } ans = (jumper != null); } return ans; }

20. while(jumper != null && ( current != jumper || start) ){ start = false; current = current.getNext(); jumper = jumper.getNext(); if (jumper != null) jumper = jumper.getNext(); } 20

21. while(jumper != null && ( current != jumper || start) ){ start = false; current = current.getNext(); jumper = jumper.getNext(); if (jumper != null) jumper = jumper.getNext(); } 21

22. while(jumper != null && ( current != jumper || start) ){ start = false; current = current.getNext(); jumper = jumper.getNext(); if (jumper != null) jumper = jumper.getNext(); } 22

23. while(jumper != null && ( current != jumper || start) ){ start = false; current = current.getNext(); jumper = jumper.getNext(); if (jumper != null) jumper = jumper.getNext(); } 23

24. while(jumper != null && ( current != jumper || start) ){ start = false; current = current.getNext(); jumper = jumper.getNext(); if (jumper != null) jumper = jumper.getNext(); } 24

25. while(jumper != null && ( current != jumper || start) ){ start = false; current = current.getNext(); jumper = jumper.getNext(); if (jumper != null) jumper = jumper.getNext(); } 25

26. Array vs. Linked List מערך יתרונות : –גישה מהירה –שימוש פשוט וקל חסרונות : –גודל קבוע שלא יכול להשתנות בזמן ריצה –הכנסת איבר חדש במקום כלשהו מצריכה השקעה רשימה מקושרת יתרונות : –גמישות ( בהינתן איבר, הוספתו \ מחיקתו בזמן קבוע ) –גודל הרשימה לא צריך להיות ידוע מראש חסרונות : –גישה " לא מהירה " למיקום ספציפי – יותר מסובך מאשר מערך 26

27. Iterator 27

28. Iterator מידע ונתונים (data) הדרושים לתכנית מחשב נשמרים בתוך מבנה נתונים (data structure). על מבנה נתונים יש צורך לבצע מספר פעולות, כמו הכנסת נתונים והוצאת נתונים. אחת הדרכים להוציא נתונים היא לעבור על אוסף הנתונים פריט - מידע אחר פריט - מידע. האחריות על מבנה הנתונים היא של המתכנת שלו, ברצוננו להקל על המשתמש במבנה הנתונים ככל הניתן. 28

29. Iterator נרצה שתכונה זו תהיה משותפת למבני נתונים רבים, למשל לרשימה, שראינו זה עתה. לכן נגדיר ממשק, שאותו כל מבנה נתונים יממש. נרצה להגיד שמבנה נתונים הוא ניתן למעבר פריט - אחר - פריט, ובאנגלית : Iterable. ב -JAVA קיים הממשק : 29 public interface Iterable { /** * Returns an iterator over a set of elements. * * @return an Iterator. */ Iterator iterator(); }

30. Iterator יהיה לנו אובייקט שיעזור בתהליך. אובייקט זה יעבור על אוסף הנתונים פריט אחר פריט, לפי סדר מסוים, ובאנגלית :Iterator. ב -JAVA מוגדר ממשק לעבודה עם אובייקט כזה : 30 public interface Iterator { boolean hasNext(); Object next(); void remove(); }

31. public interface Iterator { /** * Returns true if the iteration has more elements. * @return true if the iterator has more elements. */ boolean hasNext(); /** * Returns the next element in the iteration. * @return the next element in the iteration. * @exception NoSuchElementException iteration has no more elements. */ Object next(); /** * Removes from the underlying collection the last element returned by the * iterator (optional operation) * @exception UnsupportedOperationException if the "remove" * operation is not supported by this Iterator. * * @exception IllegalStateException if the "next" method has not * yet been called, or the "remove" method has already * been called after the last call to the "next" * method. */ void remove(); } 31

32. שימוש ב -Iterator בהמשך נראה כיצד להפוך את המחלקה LinkedList כך שתתמוך ב -Iterator, כרגע נניח שהמחלקה כבר תומכת בו, ועל סמך זאת נעשה שימוש ב -Iterator שמתקבל מהשיטה iterator(), שמובטחת לנו מכיוון ש -LinkedList מממשת את Iterable. 32 public static void main(String[] args) { LinkedList lst = new LinkedList(); lst.addLast("Shnitsels"); lst.addLast(“Are"); lst.addLast("Tasty"); Iterator it = lst.iterator(); while (it.hasNext()) { Object currentData = it.next(); System.out.print(currentData); if (it.hasNext()) System.out.print(", "); } System.out.println(); }

33. ListIterator currentLink דוגמת שימוש datanextdatanext LinkedList first 33 datanext null while (it.hasNext()) { Object currentData = it.next(); System.out.print(currentData); if (it.hasNext()) System.out.print(", "); } System.out.println(); Shnitsels,Are,Tasty

34. מימוש ה -Iterator עבור LinkedList public class ListIterator implements Iterator { private Link currentLink; //constructors public ListIterator(Link first) { currentLink = first; } public boolean hasNext() { return ( currentLink != null ); } //methods public Object next() { if (!hasNext()) { throw new NoSuchElementException(); } Object data = currentLink.getData(); currentLink = currentLink.getNext(); return data; } public void remove() { throw new UnsupportedOperationException(); } 34

35. עתה נראה כיצד נתמוך ב -Iterator במחלקה LinkedList: 35 public interface Iterable { /** * Returns an iterator over a set of elements. * * @return an Iterator. */ Iterator iterator(); } מימוש ה -Iterable במחלקה LinkedList

36. כל מה שנותר לעשות הוא לממש את השיטה iterator() של הממשק Iterable ב LinkedList: public class LinkedList implements Iterable{ private Link first; public LinkedList (){ first = null; } … // All methods remain the same public Iterator iterator(){ return new ListIterator(first); } 36

37. הערות Iterator מניח שלא נעשה שינוי באוסף עליו הוא עובר במהלך המעבר. אם נעשה שינוי – האיטרטור איננו במצב חוקי ואין הבטחה לפעולה תקינה שלו. השיטה ()next מחוייבת לזרוק את החריגה NoSuchElementException במידה ואין יותר אלמנטים באוסף. ( אם לפני כל קריאה ל -next() נוודא ש -hasNext() החזיר true אז לא נתקל בחריגה זו ). החריגה : UnsupportedOperationException נזרקת כאשר אנו מחוייבים להכריז שיטה מסויימת ( למשל כי היא חלק מממשק ) במחלקה שלנו, אך אנו לא תומכים בשיטה זו. לכן בגוף השיטה נזרוק את החריגה. 37

38. תור - Queue תור (Queue) הוא מבנה נתונים המזכיר תור של בני אדם : האיבר שנכנס ראשון לתור - יוצא ממנו ראשון. ניתן לראות כקופסה סגורה בעלת 2 פתחים : פתח הכנסה ופתח יציאה. איבר שנכנס ראשון יוצא ראשון FIFO (FIFO - First In First Out). שימושים : ניהל תהליכים ע " י מערכת ההפעלה, ניהול תור בבית מרקחת,... 38

39. public interface Queue{ /** * isEmpty - checks if the queue is empty or not. * @return true if the queue is empty */ public boolean isEmpty(); /** * dequeue - removes an object from the head of the queue. * (FIFO order) * @return the next object in the queue. */ public Object dequeue(); /** * enqueue - inserts an object into the queue. * @param o the object to be enqueued. */ public void enqueue(Object o); } 39

40. מימוש תור ע " י רשימה מקושרת public class QueueAsList implements Queue { private LinkedList lst; public QueueAsList() {lst = new LinkedList(); } public boolean isEmpty() { return lst.isEmpty(); } public Object dequeue() { return lst.removeFirst(); } public void enqueue(Object o) { lst.addLast(o); } 40

41. דוגמה נרצה לקלוט מהמשתמש מספר מחרוזות ורק כאשר הוא יסיים להקליד ( למשל ע " י זיהוי שורה ריקה ) נדפיס בחזרה את כל המחרוזות בדיוק לפי סדר ההכנסה. 41

42. המשך import java.util.Scanner; … public static void main(String args[]) { Scanner sc = new Scanner(System.in); Queue q = new QueueAsList(); System.out.println("Insert few lines … "); while (sc.hasNextLine()) { String line = sc.nextLine(); q.enqueue( line ); } System.out.println("Printing all the lines back! "); while (!q.isEmpty()) { System.out.println(q.dequeue()); } 42

43. דוגמה נוספת "'WIMBELDON" : רוצים לבצע טורניר טניס 43

44. המשך נרצה לממש את השיטה: public static Player simulateTournament(LinkedList playersList) אשר מקבלת רשימה של שחקנים ומבצעת סימולציה של טורניר טניס באופן הבא: * בשלב הראשון השחקנים מתחלקים לזוגות. * מכל זוג עולה המנצח לשלב הבא ושוב השחקנים מתחלקים לזוגות עד שנותר שחקן בודד שהוא המנצח (טורניר knock-out). 44

45. נממש את השיטה ע " י שימוש בתור – כאשר נאתחל אותו באברי הרשימה, וכל עוד התור מכיל יותר מאיבר אחד נשלוף שני שחקנים מהתור, " ניתן " להם לשחק ואת המנצח נכניס לסוף התור ( עבר לסיבוב הבא ). המשך 45

46. שחקן 1 שחקן 2 שחקן 3 שחקן 4 שלב 1: המשך שחקן 1 שחקן 2 שחקן 3 שחקן 4 46

47. שחקן 1 שחקן 2 שחקן 3 שחקן 4 שחקן 2 שחקן 4 שלב 1: שלב 2: המשך שחקן 2 שחקן 4 47 שחקן 3

48. שחקן 1 שחקן 2 שחקן 3 שחקן 4 שחקן 2 שחקן 4 שלב 1: שלב 2: המשך שחקן 2 שחקן 4 48

49. שחקן 1 שחקן 2 שחקן 3 שחקן 4 שחקן 2 שחקן 4 שחקן 2 שחקן 4 שלב 1: שלב 2: שלב 3 ( המנצח ): המשך שחקן 2 49

50. public static Player simulateTournament( LinkedList playersList) { Queue q = new QueueAsList(); Iterator it = playersList.iterator(); Player winner = null; while (it.hasNext()) { q.enqueue( it.next() ); } while ( ! q.isEmpty() ) { Player first = (Player)q.dequeue(); if (q.isEmpty()) { winner = first; } else { Player second = (Player)q.dequeue(); Player matchWinner = getWinner(first,second); q.enqueue( matchWinner ); } return winner; } 50

51. מחסנית (stack) מחסנית (stack) היא מבנה נתונים שמזכיר מחסנית של רובה : האיבר שנכנס ראשון למחסנית יוצא ממנה אחרון (LIFO - Last In First Out). ניתן לראות במחסנית קופסה סגורה בעלת פתח יחיד, שדרכו נעשות פעולות הדחיפה והשליפה. הטיפול דרך פתח יחיד יוצר מצב שבו איבר שנכנס אחרון יוצא ראשון - LIFO. מחסנית היא שימושית כאשר יש צורך לשמור נתונים בסדר מסוים ולשלוף אותם בסדר הפוך. 51

52. public interface Stack { /** * push - adds an element to the stack. * @param o the elemented to be inserted to the stack. */ public void push (Object o); /** * pop - removes an element form the stack (LIFO order). * @return the element from the top of the stack. */ public Object pop (); /** * isEmpty - checks if the stack is empty or not. * @return true if there is no more elements in the stack. */ public boolean isEmpty(); } ממשק 52

53. השיטה copy מקבלת כארגומנט מחסנית s ומחזירה העתק של המחסנית s כאשר יש לשמור על סדר האיברים במחסנית המועתקת וב-s זהה. דוגמה – העתק מחסנית public static Stack copy(Stack s) { Stack temp = new StackImpl(); Stack ans = new StackImpl(); while (!s.isEmpty()) { temp.push(s.pop()); } while (!temp.isEmpty()) { Object o = temp.pop(); ans.push(o); s.push(o); } return ans; } 53

54. השיטה filter לסינון איברים העונים על תנאי מתוך כלל איברי הרשימה. עתה נתכנן שיטה לסינון איברי הרשימה. נשאיר רק איברים העונים על תנאי כלשהו. אך מהו התנאי ? קשה לקבוע תנאי שכן רשימה היא מבנה נתונים כללי היכול להכיל איברים מסוגים שונים. 54

55. השיטה filter לסינון איברים העונים על תנאי מתוך כלל איברי הרשימה. אז מה נעשה ? נגדיר ממשק Filter המכיל שיטה אחת והיא accept, המקבלת אובייקט ומחליטה האם הוא עובר את הסינון או לא. ראשית נגדיר את הממשק Filter: 55

56. public interface Filter { /** * accept – defines the filtration criterion. * @param o the object to be examined. * @return true if the object should not be * filtered out. */ public boolean accept(Object o); } אנו נממש Filter פשוט עבור המחלקה String, המשאיר רק את המחרוזות הלא ריקות : public class EmptyStringFilter implements Filter { public boolean accept(Object o) { boolean ans = false; if (o instanceof String) { String s = (String) o; ans = s.length() > 0; } return ans; } } 56

57. היינו רוצים לממש שיטה במחלקה LinkedList, המקבלת מסנן ומחזירה רשימה מסוננת. כך שנוכל להשתמש בה באופן הבא: LinkedList lst = new LinkedList(); lst.addLast( "Hello" ); lst.addLast( "" ); lst.addLast( "Great" ); lst.addLast( "" ); lst.addLast( "World" ); LinkedList ans = lst.filter(new EmptyStringFilter()); //ans = ["Hello", "Great", "World" ] 57

58. public LinkedList filter(Filter filter) { LinkedList filteredList = new LinkedList() ; Iterator it = this.iterator(); while (it.hasNext()) { Object data = it.next(); if(filter.accept(data)) { filteredList.addLast(data) ; } return filteredList; } כל שנותר הוא לממש את אלגוריתם הסינון ב-LinkedList: האלגוריתם מקבל כקלט מסנן, ומחזיר רשימה חדשה שתכיל את כל אברי הרשימה הנוכחית שעברו את המסנן. 58

59. LinkedList lst = new LinkedList(); lst.addLast( "Hello" ); lst.addLast( "" ); lst.addLast( "Great" ); lst.addLast( "" ); lst.addLast( "World" ); LinkedList ans = lst.filter(new EmptyStringFilter()); //ans = ["Hello", "Great", "World" ] 59