אני צריך לכתוב את המחלקה הבאה:


[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://img388.imageshack.us/img388/6799/questioneq2.png]


עכשיו, עשיתי את הרוב אבל אני לא בטוח לגבי מה שאני עושה (תמיד היו לי בעיות עם מחלקות) ונתקלתי בבעיה עם החיתוך (intersect)...
אם מישהו יוכל אולי לעבור על השאלה ועל מה שעיתי ולתקן אותי אני אודה לו מאוד..

הנה מה שעשיתי עד כה:

קוד:

import unit4.collectionsLib.List;
import unit4.collectionsLib.Node;
public class IntSet
{
	private List <Integer> lst = new List <Integer> ();
	
	public IntSet()
	{
		this.lst = lst;
	}
	public boolean exists (int x)
	{
		Node <Integer> pos = lst.getFirst();
		while (pos != null)
		{
			if (pos.getInfo() == x)
				return true;
			pos = pos.getNext();
		}
		return false;
		
	}
	
	public void add (int x)
	{
		Node <Integer> pos = lst.getFirst();
		if (exists(x))
			pos = lst.insert(pos, x);
	}
	public void delete (int x)
	{
		Node <Integer> pos = lst.getFirst();
		if (pos.getInfo() == x)
			pos = lst.remove(pos);
	}
	public IntSet unify(IntSet set)
	{
		IntSet unified = new IntSet();
		Node <Integer> pos = set.lst.getFirst();
		unified.lst=lst;
		while (pos != null)
		{
			if (!unified.exists(pos.getInfo()))
				unified.add(pos.getInfo());
			pos = pos.getNext();
		}
		return unified;
		
	}
	public IntSet intersect (IntSet set)
	{
		
	}
	
}

בתודה מראש איציק!

- ה add הפוך. אם קיים(X), אז אתה לא צריך להכניס את X לרשימה
- ב delete - למה עשית תנאי pos.getInfo() == x? אין לו שום טעם..
- ב unify - אין טעם לעשות בדיקות exists כי הפונקציה add שכתבת כבר עושה אותם. כל מה שצריך לעשות בפונקציה הזאת זה להעתיק את הרשימה של האוביקט הנוכחי (אני חושב ש unified.lst = lst זה לא מספיק. צריך העתקה רדודה), ולהוסיף לו את כל הרשימה מהאוביקט שקיבלנו.
- intersect - תיצור אוביקט חדש intset ריק. תעבור על הרשימה של המספרים. עבור כל מספר, תבדוק אם הוא קיים באוביקט שקיבלת כפרמטר. אם כן, תוסיף לאוביקט החדש, אם לא, אל תוסיף.

אממ הפעולה הבונה שלי בסדר? ותיקנתי גם את דליט אז תגיד לי אם זה בסדר או אם יש עוד טעויות בזה ובכללי

ותודה

קוד:

import unit4.collectionsLib.List;
import unit4.collectionsLib.Node;
public class IntSet
{
	private List <Integer> lst = new List <Integer> ();
	
	public IntSet()
	{
		this.lst = lst;
	}
	public boolean exists (int x)
	{
		Node <Integer> pos = lst.getFirst();
		while (pos != null)
		{
			if (pos.getInfo() == x)
				return true;
			pos = pos.getNext();
		}
		return false;
		
	}
	public void add (int x)
	{
		Node <Integer> pos = lst.getFirst();
		if (!exists(x))
			pos = lst.insert(pos, x);
	}
	public void delete (int x)
	{
		Node <Integer> pos = lst.getFirst();
		while (pos != null)
		{
		if (pos.getInfo() == x)
			pos = lst.remove(pos);
		pos = pos.getNext();
		}
	}
	public IntSet unify(IntSet set)
	{
		IntSet unified = new IntSet();
		Node <Integer> pos1 = set.lst.getFirst();
		Node <Integer> pos2 = lst.getFirst();
		while (pos1 != null)
		{
			pos1 = unified.lst.insert(pos1, pos1.getInfo());
			pos1 = pos1.getNext();
		}
		while (pos2 != null)
		{
			unified.add(pos2.getInfo());
			pos2 = pos2.getNext();
		}
		return unified;
		
	}
	public IntSet intersect (IntSet set)
	{
		Node <Integer> pos = lst.getFirst();
		IntSet intersected = new IntSet ();
		while (pos != null)
		{
			if (set.exists(pos.getInfo()))
				pos = intersected.lst.insert(pos, pos.getInfo());
			pos = pos.getNext();
		}
		return intersected;
	}
	public String toString()
	{
		return lst.toString();
	}	
}

זה בנתיים המחלקה הסופית שכתבתי (יש לי בעיה ב-add שאני אסביר אחר כך)

קוד:

import unit4.collectionsLib.List;
import unit4.collectionsLib.Node;
public class IntSet
{
	private List <Integer> lst = new List <Integer> ();
	
	public IntSet()
	{
		this.lst = lst;
	}
	public boolean exists (int x)
	{
		Node <Integer> pos = lst.getFirst();
		while (pos != null)
		{
			if (pos.getInfo() == x)
				return true;
			pos = pos.getNext();
		}
		return false;
		
	}
	public void add (int x)
	{
		Node <Integer> pos = lst.getFirst();
		if (!exists(x))
			pos = lst.insert(pos, x);
	}
	public void delete (int x)
	{
		Node <Integer> pos = lst.getFirst();
		while (pos != null)
		{
		if (pos.getInfo() == x)
			pos = lst.remove(pos);
		pos = pos.getNext();
		}
	}
	public IntSet unify(IntSet set)
	{
		IntSet unified = new IntSet();
		Node <Integer> pos1 = set.lst.getFirst();
		Node <Integer> pos2 = lst.getFirst();
		while (pos1 != null)
		{
			unified.add(pos1.getInfo());
			pos1 = pos1.getNext();
		}
		while (pos2 != null)
		{
			unified.add(pos2.getInfo());
			pos2 = pos2.getNext();
		}
		return unified;
		
	}
	public IntSet intersect (IntSet set)
	{
		Node <Integer> pos = lst.getFirst();
		IntSet intersected = new IntSet ();
		while (pos != null)
		{
			if (set.exists(pos.getInfo()))
				intersected.add(pos.getInfo());
			pos = pos.getNext();
		}
		return intersected;
	}
	public String toString()
	{
		return lst.toString();
	}	
}

עכשיו רציתי להריץ תוכנית עם המחלקה כדי לראות שהכל תקין אז הכנתי את הקטע הבא:

קוד:

import java.util.Scanner;
import unit4.collectionsLib.List;
import unit4.collectionsLib.Node;
public class check
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner (System.in);
		IntSet set1 = new IntSet ();
		IntSet set2 = new IntSet ();
		for (int i=0; i<9; i++)
		{
			System.out.println("enter to first");
			set1.add(in.nextInt());
		}
		for (int i=0; i<9; i++)
		{
			System.out.println("enter to second");
			set2.add(in.nextInt());
		}
		System.out.println(set1);
		System.out.println(set2);
		System.out.println(set1.unify(set2));
		System.out.println(set1.intersect(set2));
	}
}

הכנסתי לקבוצה אחת מספרים מ 1-9, ולשנייה מ8-16 (כולל הקצוות)
הפלט שלי היה:
[1,9,8,7,6,5,4,3,2]
[8,16,15,14,13,12,11,10,9]
[8,2,3,4,5,6,7,1,9,10,11,12,13,14,15,16]
[9,8]

כלומר התוכנית פועלת כמו שצריך (נכון?!) אבל ה-add שלי לא מכניס בצורה מסודרת את האיברים לקבוצה.. יש אפשרות לסדר את זה....?

נראה שהיא פועלת כמו שצריך

מבנה אבסטרקטי של קבוצה (set) הוא לא מסודר בהגדרה שלו.
אם בכל זאת אתה רוצה שיהיה מסודר, אתה יכול לפתור את זה ב ADD. במקום להכניס במקום הראשון ברשימה, תרוץ על הרשימה עד שתמצא איבר גדול יותר מהאיבר שאתה רוצה להכניס, ואז תכניס לפניו.

אין דרך לדאוג שהאיברים פשוט יכנסו אחדש אחרי השני ?

הם כן יהיו מסודרים מהקטן לגדול כיוון שאתה עושה את זה מהאיבר הראשון שאתה מכניס.
אתה לא מקבל כבר קבוצה מוכנה ומוסיף לה איברים, אלא אתה בונה את הקבוצה מהתחלה.

או שאני לא הבנתי מה שענית

אני מתכוון שאם אני מכניס למשל את הקבוצה 3-5-6-4-5
אני רוצה שברגע שאני עושה לה טוסטרינג הפלט יהיה 3-5-6-4-5 ולא 3-5-4-6-5 (כמו שעכשיו קורה)

שאלה:
לחברת תעופה n טיסות בשבוע. כל טיסה מאופיינת על ידי קוד טיסה (לאו דווקא מספרי). בכל טיזה 300 מקומות.
הנה הפעולות שיש לחברה:
כמה-רשומים-לטיסה: מקבלת קוד טיסה ומחזירה מספר נוסעים.
האם-רשום-לטיסה: מקבלת קוד טיסה ושם נוסע ומחזירה אמת אם הנוסע רשום או לא.
שבץ-לטיסה: מקבלת קוד טיסה ושם נוסע ומשבת את הנוסע בטיסה. אם אין מקום נשבצ אותו לרשימת ההמתנה.
מחק-מטיב: מקבלת קוד טיזה ושם נוסע ומוחקת את הנוסע מהטיסה. בנוסף, שמה במקום הנוסע שנמחק נוסע אחר מרשימת ההמתנה לאותה טיסה.

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

שוב תודה רבה,
איציק.

קוד:

import unit4.collectionsLib.Node;
import unit4.collectionsLib.List;
public class flight
{

private List <String []> lst = new List <String []> ();
private List <String []> wait = new List <String []> ();

public int howMany (String code)
//ט.כניסה: הפעולה מקבלת קוד טיסה מסוג מחרוזת
//ט.יציאה: הפעולה מחזירה את כמות הנוסעים הרשומים לטיסה
//הנחה: קוד שהוכנס קיים
{
	int counter = 0;
	Node <String []> pos = lst.getFirst();
	while (pos != null)
	{
		if (pos.getInfo()[0].equals(code))
			for (int i=1; i<pos.getInfo().length; i++)
				if (!pos.getInfo()[i].equals(""))
					counter++;
		pos = pos.getNext();
	}
	return counter;		
}
public boolean isRegistered (String code, String name)
{
//ט.כניסה: הפעולה מקבלת קוד טיסה ושם נוסע, שניהם מחרוזות
//ט.יציאה: הפעולה מחזירה אמת עם הנוסע רשום לאותה טיסה ושקר אחרת
//הנחה: הקוד שהוכנס קיים	
	Node <String []> pos = lst.getFirst();
	while (pos != null)
	{	
		if (pos.getInfo()[0].equals(code))
			for (int i=1; i<pos.getInfo().length; i++)
				if (pos.getInfo()[i].equals(name))
					return true;
		pos = pos.getNext();
	}
	return false;
}
public void register (String code, String name)
{
//ט.כניסה: הפעולה מקבלת קוד טיסה ושם נוסע, שניהם מחרוזות
//ט.יציאה: הפעולה רושמת את הנוסע לטיסה בהתאם לקוד ומציגה הודעה מתאימה 
//במידה ואין מקום על הטיסה הפעולה מכניסה את הנוסע לרשימת ההמתנה לאותה טיסה ומציגה הודעה מתאימה
//הנחות: הקוד שהוכנס קיים. מקום ריק ייוצג על ידי מרחאות ריקות
	Node <String []> pos1 = lst.getFirst();
	Node <String []> pos2 = wait.getFirst();
	if (isRegistered (code, ""))
		while (pos1 != null)
		{
			if (pos1.getInfo()[0].equals(code))
				for (int i=1; i<pos1.getInfo().length; i++)
					if (pos1.getInfo()[i].equals(""))
					{
						pos1.getInfo()[i].equals(name);
						System.out.println("You are registered to fligt" + code);
					}
			pos1 = pos1.getNext();
		}	
	else
		while (pos2 != null)
		{
			if (pos2.getInfo()[0].equals(code))
				for (int i=1; i<pos2.getInfo().length; i++)
				if (pos2.getInfo()[i].equals(""))
				{
					pos2.getInfo()[i].equals(name);
					System.out.println("You are not registered to fligt" + code);
					System.out.println("Your name was put in the wait-list");
				}
			pos2 = pos2.getNext();		
		}
}
public void delete (String code, String name)
//ט.כניסה: הפעולה קוד טיסה ושם נוסע
//ט.יציאה: הפעולה מוחקת את הנוסע מאותה טיסה ומשבצת נרשם חדש מרשימת ההמתנה
//הנחה: קוד טיסה והשם שמתקבלים קיימים
{
	Node <String []> pos1 = lst.getFirst();
	Node <String []> pos2 = wait.getFirst();
	while (pos1 != null)
		if (pos1.getInfo()[0].equals(code))
			for (int i=1; i<pos1.getInfo().length; i++)
				if (pos1.getInfo()[i].equals(name))
					for (int j=1; i<pos2.getInfo().length; i++)
						if (!pos2.getInfo()[i].equals(""))
							pos1.getInfo()[i].equals(pos2.getInfo()[i]);
}	
}

ראשית, אנסה לענות על שאלותיך הספציפיות ואח"כ אציע לך דרך פתרון קצת יותר "אלגנטית" שמאפשרת קוד יותר קריא ושיותר קל להרחיבו.

לגבי הגדרת מערך בגודל מסויים:

קוד:

	private String[] myArray = new String[301];

האם הקוד שלך מתקמפל? - כי בעיקרון מגדירים כך - את ה-list ואת המימוש שלה.

קוד:

private List <String []> lst = new ArrayList <String []> ();
private List <String []> wait = new ArrayList <String []> ();

שנית,
הייתי מתכננת קצת אחרת (אם כי, אולי יש לך שיקולים אחרים לכתוב כפי שכתבת..) -

מחלקה טיסה Flight – שמייצגת טיסה אחת בלבד:

שדה String של קוד הטיסה

שדה: list של נוסעים (אם יש לך רק שמות של נוסעים – אפשר רשימה של String, אבל אני מעדיפה לבנות מחלקה של נוסע – כי אז אם יש לך נתונים נוספים על נוסע – למשל, מספר דרכון או משהו כזה – אפשר בקלות להוסיפם מבלי לשנות הרבה קוד)

שדה: list של נוסעים בהמתנה.

(אופציונאלי: שדה int של מספר הנוסעים בטיסה. אופציונאלי כי אפשר לקבל זאת בקלות לפי אורך ה-list או ה-map)



מתודות:

הייתי כותבת getters לכל השדות (למשל, getFlihgtCode יחזיר את הקוד של הטיסה וכדומה)

מתודה המחזירה את מספר הנוסעים

yourMapName.size()

בנוסף, מתודה הבודקת אם נוסע נמצא בטיסה(yourListName.Contains(yourPassenger)) – (1-2 שורות קוד..)

מתודה שמוסיפה נוסע לטיסה:

בודקת מה גודל הרשימה (list.size) אם קטן מ-300 מוסיפה לרשימה list.add אם גדול מ-300 מוסיפה לרשימת המתנה.

מתודה שמוחקת נוסע מהטיסה:

מוחקת את הנוסע בעזרת list.remove ואז בודקת אם הרשימת המתנה לא ריקה – מוסיפה (את הראשון, או האחרון – איך שתרצה) מהרשימה ההיא לרשימה הזו.



מחלקה חברת תעופה – שמייצגת את החברה על כל טיסותיה.

שדה: Map שהמפתחות שלו יהיו String (בהם נשים את קודי הטיסה) והערכים שלו יהיו Flight.

המתודות שרצית יהיו עכשיו מאוד פשוטות:

כמה רשומים לטיסה:

- חיפוש ב-Map שלנו לפי המפתח (שהוא הקוד טיסה שאותו אתה מקבל כפרמטר למתודה הזו) – כלומר yourMapName.get(theFlightCode) יחזיר לך את הטיסה.

- עבור הטיסה הזו שקיבלת תקרא למתודה שמחזירה את מספר הנוסעים בטיסה

(בס"ה 2-3 שורות קוד..)



האם רשום לטיסה:

- חיפוש ב-Map שלנו לפי המפתח (שהוא הקוד טיסה שאותו אתה מקבל כפרמטר למתודה הזו) – כלומר yourMapName.get(theFlightCode) יחזיר לך את הטיסה.

- עבור הטיסה הזו שקיבלת תקרא למתודה שבודקת את הנוסע בטיסה.

(בס"ה 2-3 שורות קוד..)



שבץ לטיסה –

- חיפוש ב-Map שלנו לפי המפתח (שהוא הקוד טיסה שאותו אתה מקבל כפרמטר למתודה הזו) – כלומר yourMapName.get(theFlightCode) יחזיר לך את הטיסה.

- עבור הטיסה הזו שקיבלת תקרא למתודה שמוסיפה את הנוסע לטיסה.

(בס"ה 2-3 שורות קוד..)



מחק מטיסה –

- חיפוש ב-Map שלנו לפי המפתח (שהוא הקוד טיסה שאותו אתה מקבל כפרמטר למתודה הזו) – כלומר yourMapName.get(theFlightCode) יחזיר לך את הטיסה.

- עבור הטיסה הזו שקיבלת תקרא למתודה שמוחקת את הנוסע מהטיסה.

(בס"ה 2-3 שורות קוד..)

בהצלחה, סיון

השתדל להנות מהדברים הקטנים בחיים.
יום יבוא ובמבט לאחור תגלה שהיו אלה דברים גדולים...

עזרת לי מאוד