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

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

3. מחלקה שמייצגת חוליה 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

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

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

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

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

8. דוגמת שימוש 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

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

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

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

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

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

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

15. 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;
&&

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

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

18. 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;

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

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

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

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

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

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

25. Iterator

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

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

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

29. public interface Iterator {
/**
* Returns true if the iteration has more elements.
true if the iterator has more elements. */
boolean hasNext();
* Returns the next element in the iteration.
the next element in the iteration.
NoSuchElementException iteration has no more elements.
Object next();
* Removes from the underlying collection the last element returned by the
* iterator (optional operation)
UnsupportedOperationException if the "remove"
* operation is not supported by this Iterator. *
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(); }

30. שימוש ב-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();

31. דוגמת שימוש 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

32. מימוש ה-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();

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

34. מימוש ה-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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

54. 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;

55. היינו רוצים לממש שיטה במחלקה 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 מחוץ לקריאה לפונקציה

56. כל שנותר הוא לממש את אלגוריתם הסינון ב-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;

57. 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" ]