ומחסניתIteratorרשימה מקושרת, תור,

Slides:



Advertisements
Similar presentations
Completeness and Expressiveness. תזכורת למערכת ההוכחה של לוגיקה מסדר ראשון : אקסיומות 1. ) ) (( 2. )) ) (( )) ( ) ((( 3. ))) F( F( ( 4. ) v) ( ) v ((
Advertisements

תוכנה 1 סמסטר א ' תשע " ב תרגול מס ' 7 * מנשקים, דיאגרמות וביטים * לא בהכרח בסדר הזה.
מבוא למדעי המחשב לתעשייה וניהול
בתרגול הקודם הורשה: –ניתן להרחיב רק מחלקה אחת –כל מה שלא private – עובר בהורשה –המילה השמורה super –יצירת היררכיה –Object היא שורש ההיררכיה –דריסה אופרטור.
1 Formal Specifications for Complex Systems (236368) Tutorial #4 Refinement in Z: data refinement; operations refinement; their combinations.
Interface ממשקים 1. ראינו כי ניתן לשמור אובייקטים במערכים באותו אופן כמו משתנים רגילים. ננסה כעת לראות כיצד למיין מערך של אובייקטים מסוג מסוים. נשתמש.
COMP 103 Linked Stack and Linked Queue.
טבלאות סמלים נכתב ע"י אלכס קוגן סמסטר חורף, תשס"ח.
תכנות מונחה עצמים Object Oriented Programming (OOP) אתגר מחזור ב'
מתמטיקה בדידה תרגול 3.
רשימה מקושרת Linked Lists. דוגמא STRING איך עושים Dim x as String בלי לדעת מראש את הגודל !
חורף - תשס " ג DBMS, Design1 שימור תלויות אינטואיציה : כל תלות פונקציונלית שהתקיימה בסכמה המקורית מתקיימת גם בסכמה המפורקת. מטרה : כאשר מעדכנים.
תרגול 5 רקורסיות. רקורסיה קריאה של פונקציה לעצמה –באופן ישיר או באופן עקיף היתרון : תכנות של דברים מסובכים נעשה ברור ונוח יותר, מכיוון שזו למעשה צורת.
חורף - תשס " ג DBMS, צורות נורמליות 1 צורה נורמלית שלישית - 3NF הגדרה : תהי R סכמה רלציונית ותהי F קבוצת תלויות פונקציונליות מעל R. R היא ב -3NF.
Unit 11 1 Unit 11: Data Structures H We explore some simple techniques for organizing and managing information H This unit focuses on: Abstract Data Types.
1 Formal Specifications for Complex Systems (236368) Tutorial #5 Refinement in Z: data refinement; operations refinement; their combinations.
בהסתברות לפחות למצא בעיה במודל PAC עבור בהסתברות ε הפונקציה f טועה מודל ONLINE 1. אחרי כל טעות הפונקציה משתפרת 2. מספר הטעיות קטן.
אוניברסיטת בן גוריון - מבוא למדעי המחשב 1 תרגול מספר 10  ממשקים o כללים בסיסיים o מימוש מספר ממשקים o דוגמת ממשק כחוזה  הורשה o כללים בסיסיים o דריסה.
א " ב, מילים, ושפות הפקולטה למדעי המחשב אוטומטים ושפות פורמליות ( ) תרגיל מספר 1.
Formal Specifications for Complex Systems (236368) Tutorial #6 appendix Statecharts vs. Raphsody 7 (theory vs. practice)
תכנות תרגול 6 שבוע : תרגיל שורש של מספר מחושב לפי הסדרה הבאה : root 0 = 1 root n = root n-1 + a / root n-1 2 כאשר האיבר ה n של הסדרה הוא קירוב.
Stacks and Queues. Stack ADT סוג של מערך מוגבל מהר מאוד ולוקחים מעט זכרון שימוש ב LIFO – LIFO (Last In, First Out) lists. –אפשר להוסיף רק בסוף הרשימה.
עקרון ההכלה וההדחה.
יחס סדר חלקי.
תכנות מונחה עצמים Object Oriented Programming (OOP) אתגר מחזור ב' Templates תבניות.
מבוא למדעי המחשב תרגול 3 שעת קבלה : יום שני 11:00-12:00 דוא " ל :
מבוא למדעי המחשב, סמסטר א ', תשע " א תרגול מס ' 1 נושאים  הכרת הקורס  פסאודו - קוד / אלגוריתם 1.
תרגול 12: ומחסניתIteratorרשימה מקושרת, תור, 1. רשימה מקושרת (Linked List) רשימה מקושרת הינה קבוצה סדורה של אובייקטים, כאשר כל אובייקט ברשימה מכיל הצבעה.
מבוא מורחב למדעי המחשב בשפת Scheme תרגול 10. אג'נדה שאלות מבחינות חזרה על מימוש stream אפשרי 2.
1 Lecture 26 Abstract Data Types – IV Overview  The List ADT  Implementing Stacks as Linked List  Linked List Implementation of Queues .  Preview:
1 מבוא למדעי המחשב סיבוכיות. 2 סיבוכיות - מוטיבציה סידרת פיבונאצ'י: long fibonacci (int n) { if (n == 1 || n == 2) return 1; else return (fibonacci(n-1)
פיתוח מערכות מידע Class diagrams Aggregation, Composition and Generalization.
LinkedList Many slides from Horstmann modified by Dr V.
CMSC 341 Linked Lists, Stacks and Queues. 8/3/2007 UMBC CMSC 341 LSQ 2 Implementing Your Own Linked List To create a doubly linked list as seen below.
09-1 Queues and List-Based ADT Implementations Problem Set: PS3 due Wednesday, March 7 Wellesley College CS230 Lecture 09 Monday, February 26 Handout #18.
בתרגול הקודם כללי הרשאות (Visibility modifiers) בהורשה – Public – Protected – private חוקי גישה לשדות ושיטות בהורשה ב -Java מחלקות אבסטרקטיות –המילה השמורה.
1 מבוא למדעי המחשב הרצאה 21: Queue, Iterator & Iterable.
תרגול 12: Iterator מחסנית תור 1. מחסנית (stack) מחסנית (stack) היא מבנה נתונים שמזכיר מחסנית של רובה : האיבר שנכנס ראשון למחסנית יוצא ממנה אחרון (LIFO.
מחסנית ותור Stacks and Queues. מחסנית Stack מחסנית - Stack ADT סוג של מערך מוגבל מהיר מאוד ותופס מעט זיכרון שימוש ב LIFO – LIFO (Last In, First Out)
Practice session 6 Sequence Operations Partial Evaluation Lazy Lists.
1 Stacks (Continued) and Queues Array Stack Implementation Linked Stack Implementation The java.util.Stack class Queue Abstract Data Type (ADT) Queue ADT.
מחסנית ותור Stacks and Queues. מחסנית Stack מחסנית - Stack ADT סוג של מערך מוגבל מהיר מאוד ותופס מעט זיכרון שימוש ב LIFO – LIFO (Last In, First Out)
מבנה נתונים או טיפוס נתונים מופשט חלק ב – פעולות על רשימה הוכן ע " י ולרי פקר דצמבר 2015.
1 נתבונן בפונקציה הבאה public static int min(int[] a,int n) { int min = a[0]; for (int i = 1; (i < n ) && (i < a.length) ; i++) if (min > a[i]) min = a[i];
1 Formal Specifications for Complex Systems (236368) Tutorial #1 Course site:
Chapter 4 ADTs Stack and Queue. 4-2 Formal ADT Specifications The Java interface construct lets us collect together method interfaces into a syntactic.
Iterators. Iterator  An iterator is any object that allows one to step through each element in a list (or, more generally, some collection).
Linked Data Structures
האוניברסיטה העברית בירושלים
Programming Arrays.
מבני נתונים רשימה מקושרת, מחסנית ותור
Tirgul 12 Trees 1.
Formal Specifications for Complex Systems (236368) Tutorial #1
מחלקות classes.
מבוא למדעי המחשב סיבוכיות.
תירגול 14: מבני נתונים דינאמיים
עבודה עם נתונים באמצעות ADO.NET
תכנות מכוון עצמים בשפת JAVA
ממשקים - interfaces איך לאפשר "הורשה מרובה".
Marina Kogan Sadetsky –
הרצאה 21: Queue, Iterator & Iterable
בניית מחסנית סטטית Static Stack Implementation מורים מובילים תשע"ה
תכנות מכוון עצמים ושפת JAVA
הכמסה – Encapsulation עקרון ההכמסה
Initializing Objects.
Linked Lists [AJ 15].
מחסנית ותור Stacks and Queues.
מבוא לתכנות ב- Java תרגול 10 - רשימות מקושרות.
פולימורפיזם מתקדם ממשקים בC# עריכה ועיצוב: קרן הרדי
Lecture 16 Stacks and Queues CSE /26/2018.
Presentation transcript:

ומחסניתIteratorרשימה מקושרת, תור, תרגול 12: ומחסניתIteratorרשימה מקושרת, תור,

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

מחלקה שמייצגת חוליה Link public class Link { private Object data; private Link next; 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) { public Link getNext() { return next; public void setNext(Link next) { Data Next Link

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

מחלקה שמייצגת רשימה משורשרת LinkedList null LinkedList data next first 5

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

נוסיף למחלקה את השיטה: 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);

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

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

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

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

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

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

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

getMiddle 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; &&

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

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

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) ans = (jumper != null); return ans;

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

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

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

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

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

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

Iterator

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

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

Iterator יהיה לנו אובייקט שיעזור בתהליך. אובייקט זה יעבור על אוסף הנתונים פריט אחר פריט, לפי סדר מסוים, ובאנגלית:Iterator . ב-JAVA מוגדר ממשק לעבודה עם אובייקט כזה:

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(); }

שימוש ב-Iterator בהמשך נראה כיצד להפוך את המחלקה LinkedList כך שתתמוך ב-Iterator, כרגע נניח שהמחלקה כבר תומכת בו, ועל סמך זאת נעשה שימוש ב-Iterator שמתקבל מהשיטה iterator(), שמובטחת לנו מכיוון ש-LinkedList מממשת את Iterable. 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();

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

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

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

מימוש ה-Iterable במחלקה LinkedList עכשיו כל מה שנותר לעשות הוא לממש את השיטה 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);

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

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

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); }

מימוש תור ע"י רשימה מקושרת 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);

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

המשך 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());

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

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

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

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

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

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

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

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; 48

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

ממשק 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(); }

דוגמה – העתק מחסנית השיטה 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;

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

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

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;  

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

כל שנותר הוא לממש את אלגוריתם הסינון ב-LinkedList: האלגוריתם מקבל כקלט מסנן, ומחזיר רשימה חדשה שתכיל את כל אברי הרשימה הנוכחית שעברו את המסנן. 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 lst = new LinkedList(); lst.addLast( "Hello" ); lst.addLast( "" ); lst.addLast( "Great" ); lst.addLast( "World" );   LinkedList ans = lst.filter(new EmptyStringFilter()); //ans = ["Hello" , "Great" , "World" ]