לקראת בגרות לקראת בגרות תרגילים ברשימות תרגילים ברשימות

ועציםועצים

– רחל לודמר, זיוה קוצמן, דיתה אוהב ציון12/3/2009עיצוב תוכנה : השתלמות ת"א

הערות והארות שנאמרו / הועלו במפגש ההשתלמות

לכל פעולה יש להוסיף תיעוד: טענת כניסה ויציאה. 1. נקודות(.2 מהשאלה )5%בבגרות אם אין תיעוד לשאלה מורידים

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

איתחול והצהרה של משתנים מקומיים בכל פעולה.2.

תרגול של כתיבת פעולות פנימיות. )ראה בחינות בגרות במתכונת החדשה(3.

.4 מחלקות ולא יותר מ-2בבעיות מורכבות מומלץ שיהיו לפחות 4.

get, set)בבעיות מורכבות, אין צורך במימוש פעולות האיחזור והקביעה.)5.יש צורך ברישום ההנחה שהפעולות קיימות ואין צורך לממשם.

עבור תכונות כאשר נמצאים set, getשימוש תחבירי נכון של פעולות ה- 6..שם העצםget)(התכונה. : מחוץ למחלקה שבה הוגדרו

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

כשיש "הרכבה" של איחזור תכונות במבנה מורכב, רצוי להשתמש במשתני עזר ב"דרך", על מנת 7.למנוע בלבול וסרבול.

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

כלל: אם אתה המורה מתלבט ב"ניסוח החדש" לשאלה, אל תבקש מהתלמיד ל"פתור את התלבטויותיך"

- וותר על שאלה זו.

:1תרגיל .xכתוב פעולה חיצונית המקבלת רשימה של מספרים שלמים, ומספר נוסף

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

-999יש להחזיר x אם אין איבר ברשימה הגדול מ- .10 יוחזר x=8 והמספר lst: 7, 4, 12, 6,10,15דוגמא: עבור הרשימה

פתרון:

num>x{ כאשר {num - xיש לחפש את ההפרש הקטן ביותר מבין כל ההפרשים של: public static int nearX)list<Integer> lst(

}

Node<Integer> pos=lst.getFirst)(;

while )pos!=null && pos.getInfo)(<x(

pos=pos.getNext)(;if )pos==null( return -999;

int min=pos.getinfo)(-x;

while)pos!=null(

} if )pos.getInfo)(-x<min && pos.getinfo)(>= x(

min=pos.getInfo)(-x;

pos=pos.getNext)(;}return min+x;}

:2תרגיל אשר מקבלת רשימת מספרים לא ריקה, הפעולה מוחקת lastAndRemoveנתונה הפעולה הבאה:

את האיבר האחרון ברשימה ומחזירה את ערכו. )public static int lastAndRemove)List<Integer> lst א. ממש פעולה זו:

TwoItems

תכונות:num1מספר שלם: num2מספר שלם:

פעולה בונה:TwoItems(int num1,int num2)

הבא: UMLנתון ה-

זה הכולל : תכונות , פעולה בונה, פעולות איחזור UMLהנח שנבנתה מחלקה מתאימה עבור וקביעה.

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

יהיה הזוג lst2, האיבר השני ב- lst1 יהיה הזוג המורכב מהראשון והאחרון מרשימה lst2ברשימה , וכך הלאה.lst1המורכב מהשני והלפני האחרון ברשימה

אם הרשימה היא באורך אי זוגי האיבר האמצעי ישוכפל.

lst1 475326nullלמשל, עבור הרשימה:

Lst246

732

55

null הרשימה שתוחזר:

public static int lastAndRemove)List<Integer> lst(

}

Node<Integer>pos=lst.getFirst;)(

while )pos.getNext)(!=null( pos=pos.getNext;)(

int last=pos.getInfo;)(

lst.remove)pos(;

return last;

}

פתרון א:

public static List<TwoItems> zugot)List<Integer> lst1(} List<TwoItems>lst2=new List<TwoItems> )(; Node<TwoItems> p=lst2.getFirst)(;while)!lst1.isEmpty)((} int x=lst1.getFirst)(.getInfo)(; int y=lastAndRemove)lst1(; TwoItems t=new TwoItems)x,y(; p=lst2.insert)p,t(; if )!lst1.isEmpty)(( lst1.remove)lst1.getFirst)((; //מחיקת האיבר הראשון ברשימה}return lst2;}

פתרון ב:

:3שאלה , כשכל מספר n עד 1" הוא עץ המכיל את כל המספרים השלמים מ- n"עץ עוקבים -

מופיע בו פעם אחת בלבד. , ומחזירה אמת אם העץ הוא "עץ עוקבים n ומספר טבעי tכתוב פעולה המקבלת עץ

-n האם בהכרח מספר הצמתים הוא( .ושקר אחרת ,"n)?

public static int countItem)BinTreeNode<Integer> bt, int x(}

if )bt==null ( return 0;

else if )bt.getInfo)(==x(

return )1+countItem)bt.getLeft)(,x(+countItem)bt.getRight)(,x((; else

return )countItem)bt.getLeft)(,x(+countItem)bt.getRight)(,x((;}

public static boolean okvimN)BinTreeNode<Integer> bt, int n(}

for )int x=1; x<=n; x++( if )countItem)bt,x(!=1(

return false; return true;

}

הפעולה נעזרת בפעולת עזר המונה כמה פעמים הופיע ערכו של צומת

אפשר לפתור את הבעיה גם בעזרת מערך מונים

ביעילות טובה יותר.

:4שאלה נגדיר רשימה-ציקלית כרשימה שבה בכל חוליה, שדה המידע מכיל מספר סידורי של חוליה

אחרת ברשימה. כך שאם נתחיל בחוליה הראשונה ונעבור ממנה לחוליה הבאה )בהתאם לתוכן שלה( וכך הלאה בהתאם לתכני החוליות – נגיע בסוף חזרה לחוליה הראשונה , אחרי

החוליות. הנח שערכי האיברים ברשימה הציקלית הם שונים זה מזה.כלשעברנו על 4לדוגמא : עבור הרשימה הבאה: 3 6 7 1 5 2

7 6 5 4 3 2 1

1 → 5 → 6→ 3 → 2 → 7 → 4→ 1המסלול יהיה )משמאל לימין(:

לפניך מספר פעולות :Node<Integer> getPosition)List<Integer> L , int n(

. הפעולה n ומספר שלם Integer מטיפוס Lהפעולה מקבלת רשימה , אם לא קיימת חוליה כזו ערכו של nמחזירה את החוליה במקום

nullהמיקום יהיה רשימה מאותחלת.Lהנחה :

boolean isCyclic)List<Integer> L( הפעולה מקבלת רשימהL מטיפוס Integer ומחזירה אמת אם הרשימה ציקלית אחרת מחזירה שקר

int lenList)List <Integer> L( הפעולה מקבלת רשימהL מטיפוס Integer ומחזירה את מספר האיברים ברשימה

הנחה : הרשימה מאותחלת

)Node<Integer> getPosition)List<Integer> L , int nא. ממש את הפעולה . )boolean isCyclic)List<Integer> Lב. ממש את הפעולה

, מבלי לממש אותה. )lenList)List <Integer> L ניתן להשתמש בפעולה

public static Node<Integer> getPosition)List<Integer> L , int n(}

Node<Integer> pos=L.getFirst;)( for )int i=1; i<n && pos!=null; i++(

pos=pos.getNext;)( return pos;

}public static boolean isCyclic)List<Integer> L(

} int n=lenList)L(;

Node<Integer> pos=L.getFirst;)( List<Integer> L2=new List<Integer;)(<

Node<Integer> pos2=L2.getFirst;)( pos2=L2.insert)pos2,1(;

int mone=1; while)pos!=null && pos.getInfo)(!=1 && mone<n(

} pos2=L2.insert)pos2,pos.getInfo)((;

pos=getPosition)L , pos.getInfo)((; mone;++

} if )mone==n && pos!=null(

return true; else

return false;}

פתרון – רשימה צקלית

בנית הרשימה החדשה אינה חובה.

אפשר להשתמש במונה.

4 3 6 7 8 5 2

7 6 5 4 3 2 1

שים לב,לתנאי הנוסף!למרות שעברנו על כל החוליות,

לא הגענו בחזרה לחוליה הראשונה.

:5שאלה שורות המכילות עגלות )השורות באורכים שונים(. אדם המבקש לקחת kבסופר-מרקט יש

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

ומספר המציין כמה פעמים נלקחה העגלה code)כל עגלה מזוהה ע"י קוד משלה )(count.)

מהמחלקות:כל אחתא. כתוב את הכותרת ואת התכונות בעבור

- עגלה Carriage - שורת עגלות LineCarriage - מאגר עגלות בסופר SuperCarriage

. LineCarriage) )במחלקה takeCarriageב. כתוב פעולה פנימית בשם הפעולה מחזירה את העגלה שהאדם לקח מהשורה.

המקבלת returnCarriage( פעולה פנימית בשם LineCarriageג. כתוב )במחלקה ומחזירה אותה לשורה. aכפרמטר עגלה

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

הנח שיש אחת כזו.

הערה : והפעולות getהנח כי במחלקות שלעיל קיימות כל הפעולות המאחזרות

.setהקובעות

public class Carriageא. הגדרת המחלקות:

}

private int code;

private int count;

...........

}

public class LineCarriage}

private List<Carriage> line;

...........}

אפשר גם מחסנית

פחות נוח לעבודה

בסעיפים ד-ה

public class SuperCarriage} private LineCarriage [ ] allLines;................}

מותר לקחת ולהחזיר עגלה רק בסוף

השורה

ללקיחת LineCarriageב. פעולה פנימית במחלקה עגלה

public Carriage takeCarriage)(} Node<Carriage>pos= this.line.getLast)(; Carriage a=pos.getInfo)(; a.setCount)a.getCount)(+1(; this.line.remove)pos(; return a;}

ניעזר בפעולת עזר המחזירה )הפניה(

לעגלה האחרונה

public Node<Carriage> getLast)(

}

Node<Carriage>pos= this.line.getFirst)(;

while )pos.getNext)(!=null(

pos=pos.getNext)(;

return pos;

}

להחזרת LineCarriageג. פעולה פנימית במחלקה )public void returnCarriage) Carriage aעגלה

} Node<Carriage>pos= this.line.getLast)(; this.line.insert)pos,a(;}

להחזרת ההפניה לעגלה superCarriageד. פעולה פנימית במחלקה )(public Node<Carriage> popularCarriageהפופולרית

} int max=0; Node<Carriage> popular=null;for )int i=0; i<this.allLines.length; i++(} Node<Carriage> pos=this.allLines[i].getLine)(.getFirst)(; while )pos!=null( } if )pos.getInfo)(.getCount)(>max( } max= pos.getInfo)(.getCount)(; popular=pos; } pos=pos.getNext)(; }//end while } //end forreturn popular;}

תוספת ** (לתרגול בכיתה)הסופר קבל עגלות חדשות )מספרן קטן מאד ביחס למספר העגלות הכללי(, ומעוניין

להחליף את העגלות הפופולאריות ביותר, בסדר יורד. המקבלת רשימה של קודים של עגלות superCarrigeכתוב פעולה פנימית במחלקה

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

מחלקה נכתבו.public void replaceCarriage)List<Integer> codeL(} Node<Integer> p=codeL.getFirst)(; while )p!=null( } Node<Carriage> pos=this.allLines.popularCarriage)(; Carriage a=pos.getInfo)(; a.setCode)p.getInfo)((; a.setCount)0(; pos.setInfo)a(; p=p.getNext)(; }}

:6שאלה נתונה הפעולה הבאה:

public static boolean sodTree)BinTreeNode<Integer> t(}

If )Leaf)t(( return true;

if )t.getLeft)(!=null( if )Leaf)t.getLeft)(( && t.getRight)(!=null(

return sodTree)t.getRight)((; return false;

} תחזיר 'אמת'.sodTree צמתים, כך שהפעולה 5א. תן דוגמא לעץ בינארי המכיל לפחות תחזיר 'שקר'.sodTree צמתים, כך שהפעולה 5ב. תן דוגמא לעץ בינארי המכיל לפחות

?sodTreeג. מה מטרת הפעולה

ג. המטרה היא להחזיר אמת ב. א. אם העץ הוא עץ שורש או עץ

עם שני תתי עצים כך שכל תת עץ

שמאלי הוא עלה וכל תת עץ ימני

מקיים את מטרת העץ.

פעולת "עץ עלה" - Leaf!נתונה ,

:7שאלה הבא: UMLנתון ה-

Pairתכונות:

tavתו: ,numמספר הופעות של התו :

num>0פעולה בונה:

Pair(char tav, int num) הנח שנבנתה מחלקה מתאימה עבורUML זה הכולל : תכונות , פעולה בונה, פעולות איחזור וקביעה.

. על הפעולה להחזיר רשימה Pairכתוב פעולה חיצונית המקבלת עץ בינארי שאיבריו הם מטיפוס שאיבריה הם התווים שבערכי הצמתים, תווים זהים יהיו ברצף, ואורך הרצף יהיה סה"כ מספר

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

3

D 2

E 3

C

1

T

2

B 2

C 2

E

1 הרשימה שתוחזר:

lstC C C C C C D D T T E E E E B B null

פתרון: שים לב בנוסף לעץ , הפעולה מקבלת גם רשימה

)public static void ex7)BinTreeNode<Pair> bt, List<Character>lstמאותחלת.} if )bt!=null( } putInList)lst,bt.getInfo)(.getTav)(,bt.getInfo)(.getNum)((; ex7)bt.getLeft)(,lst(; ex7)bt.getRight)(,lst(; }}

)public static void putInList)List<Character>lst, char tav, int countמימוש פעולת העזר: } Node<Character> pos = lst.getFirst)(; while )pos!=null && pos.getInfo)(!=tav( pos=pos.getNext)(; for )int i=1; i<=count; i++( lst.insert)pos,tav(;}

הבא: UMLנתון ה-

Pair:8שאלה

תכונות: int value

int howManyBig

פעולה בונה: Pair(int num, int howManyBig)

זה הכולל : תכונות , פעולה בונה, פעולות איחזור UMLהנח שנבנתה מחלקה מתאימה עבור וקביעה.

מייצגת ערך האיבר ברשימה, value. התכונה Pairנתונה רשימת מספרים שאבריה הם מטיפוס מייצגת את מספר האיברים ברשימה שאחרי האיבר הנוכחי, כך שערך התכונה howManyBigוהתכונה

value שלהם גדולה מערך התכונה value .של האיבר הנוכחי לדוגמא:

L52

23

42

80

70

10

null

שאיבריה Lהמקבלת כפרמטרים רשימה addNumber כתוב פעולה חיצונית בשם . על הפעולה להוסיף איבר לרשימה place ומספר שלם num, מספר שלם Pairמטיפוס

L -כך שערך תכונת ה , value שלו הוא num במקום סידורי ,place-ברשימה, )ה place (.1של האיבר הראשון ברשימה הוא

, כך שאחרי ההכנסה יש לשמור על חוקי הרשימה לגבי התכונה Lיש לעדכן את הרשימה howmanyBig.

, הרשימה תעודכן ל-addNumber(L,3,5)לדוגמא: עבור הרשימה הנ"ל והזימון L5

22

44

28

03

17

01

0null

) public static void addNumber)List<Pair> lst, int num, int placeפתרון:} Node<Pair> pos=lst.getFirst)(, pos2; Pair x=new Pair)num,0(; If )place==1( lst.insert)null,x(; else } for )int i=1; i<place; i++( pos=pos.getNext)(; lst.insert)pos,x(; } pos=lst.getFirst)(; for )int i=1; i<place; i++( } if) pos.getInfo)(.getValue)(<num( } int t= pos.getInfo)(.setHowManyBig)(; pos.getInfo)(.setHowManyBig)t+1(;} pos=pos.getNext)(; } int count=0; pos2=pos.getNext)(; while)pos2!=null( } if )pos2.getInfo)(.getValue)(>num( count++; pos2=pos2.getNext)(; } pos.getInfo)(.setHowManyBig)count(;}

תקין placeהנחה: בתחום גודל

הרשימה.

עדכון הרשימה:את הרשימה ניתן לעדכן עי" לולאה כפולההעוברת על כל איבר, וסופרת מחדש כמה

.o(n2)גדולים ממנו והלאה – יעילות

:o(n)הפתרון המוצג הוא ביעילות

ונמצא לפניו.num עדכון כל איבר הקטן מ – - (פעולה שניתן לבצעה תוך כדי איתור

מיקומו )num הסידורי של

במספר האיברים num עדכון החוליה של -

שגדולים ממנו ונמצאים אחריו.

.המקבלת שורש של עץ בינרי ומספר שלם, נתונה השיטה הבאהpublic static boolean sod)BinTreeNode<Integer> t, int num(}if)t==null(

return true;return )t.getInfo)( > num && sod)t.getLeft)(, t.getInfo)((&&

sod)t.getRight)(, t.getInfo)((;)}

:9שאלה

:עבור העץ הבינרי הבא 8

1116

15

19

14 1225

13 10

?)sod)t,-1מה תחזיר הפעולה עבור הזימון:. אב. שנה ערכו של צומת אחת או יותר, כך

שהפעולה תחזיר ערך שונה מזה שקבלת בסעיף א'.

על השינוי להיות מינמלי בעץ. צייר מחדש את העץ המעודכן.

א. מטרת הפעולה להחזיר אמת אם נתון, num ערך שורש העץ גדול מ-

וערך של כל בן גדול מערך אביו.

ב.

8

1116

20

19

14 1225

28 16

שאלה הבאה שמקבלת כפרמטר הפניה לשורש של עץ בינרי: Mysteryנתונה הפעולה :10

public static void Mystery)BinTreeNode<char> t(}

if )t != null( }

Console.WritLine )t.GetInfo)( + " "(;Mystery )t.GetLeft)((;Console.WritLine )t.GetInfo)(+ " "(;Mystery )t.GetRight)((;Console.WritLine )t.GetInfo)(+ " "(;

}} ( i) מה תדפיס הפעולהmystery כאשר היא תקבל את השורש של העץ root?הבא

a

c b

e d

f

root

ii) ציירו עץ שאם )root -פונה לשורש שלו אז קריאה ל mystery)root( תדפיס את השורה הבאה:

b a c c d d d c a e e f f f e a b b

a,b,b,d,d,d,b,a,c,e,f,f,f,e,e,c,c,aא.

b a c c d d d c a e e f f f e a b bב. עבור הפלט: b העץ שיתקבל:

c

a

d

e

f

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

5,8,3, 5,8,3, 5,8,3דוגמה: של מספרים שלמים ומחזירה 'אמת' אם L כתוב פעולה חיצונית, המקבלת רשימה

הרשימה היא מחזורית ו'שקר' אחרת

:11שאלה

פתרון:

public static bool Machzorit)List<int> l(}

bool takin = true; int count=1, mone=0; Node<int> pos1 = l.GetFirst)(, pos2 = null;

if )pos1 != null( pos2 = pos1.GetNext;)(

while )pos2 != null && pos2.GetInfo)( != pos1.GetInfo)((}

pos2 = pos2.GetNext;)( count++; }

if )pos2 == null( return false;

while )pos2 != null && takin ( }

if )pos1.GetInfo)( == pos2.GetInfo)((}

mone;++ pos1 = pos1.GetNext;)( pos2 = pos2.GetNext;)(

} else

takin = false; if )mone==count(

mone=0;}

return )pos2 == null && takin && mone==0( }

הם שני אחים בעץ שערכם שווה.תאומים הוא עץ עלה או שורש ושני תתי עצים, שכל אחד מהם הוא עץ עץ תאומים

תאומים, כך שמספר התאומים בתת העץ השמאלי קטן או שווה למספר התאומים בתת העץ הימני.

כתבו פעולה המקבלת עץ בינארי ומחזירה 'אמת' אם הוא עץ תאומים ו'שקר' אחרת.

שאלה 12:

פתרון: נפרק את הבעיה לשתי תתי משימות :

אחים הם תאומים2 - בדיקה שכל - מספר התאומים בכל תת עץ שמאלי קטן או שווה למספר התאומים בתת

עץ ימני

דוגמא לעץ תאומים

דוגמא לעץ שאינו עץ תאומים

public static boolean leaf)BinTreeNode<Character> bt(}

return ) bt.getLeft)(==null && bt.getRight)(==null(;}

פתרון:

public static int countTwins)BinTreeNode<Character> bt(} if )leaf)bt(( return 1; else return )1+countTwins)bt.getLeft)((+ countTwins)bt.getRight)(((;

}

public static boolean twins)BinTreeNode<Character> t(}

if )leaf)t(( return true;

if) t.getLeft)(!=null && t.getRight)(!=null( } if )t.getLeft)(.getInfo)(==t.getRight)(.getInfo)(( }

boolean ok= twins)t.getLeft)(( && twins)t.getRight)((; return ok &&

} else return false; } return false; } return false;

}

countTwins)t.getLeft)((-1<=countTwins)t.getRight)((-1;

מכל מניית 1לא חובה להוריד התאומים בתת עץ. וזאת על

מנת שלא ימנה את שורש התת עץ במספר התאומים.

שאלה 13:

זוגיn( n.)נתונה רשימה של מספרים שלמים באורך ובה שתי תכונות:TwoListsקיימת מחלקה בשם

•List<int> listA •List<int> listB

עליכם לממש את הפעולה החיצונית הבאה:public static TwoLists Split)List<int> lst(

, כך n/2על הפעולה לחלק את איברי הרשימה הנתונה לשתי רשימות, כל אחת באורך הפעולה צריכה להחזיר שההפרש בין סכום איברי שתי הרשימות יהיה המכסימלי.

המכיל את שתי הרשימות החדשות.TwoListsאובייקט מהמחלקה לדוגמה: אם הרשימה עליה מופעלת הפעולה היא:

54 9 2 21

אז האובייקט שיוחזר יהיה :9

21

2

54

האחת תכיל את TwoLists לבנות שתי רשימות מטיפוס דרך פתרון:המספרים המכסימליים והשניה תכיל את המינימליים. כל אחת

n/2.באורך

פתרון: public static Node<int> MaxInList)List<int> l(

} Node<int> pos = l.GetFirst;)(

int max = pos.GetInfo;)( Node<int> placeMax = pos;

pos = pos.GetNext;)( while )pos != null(

} if )pos.GetInfo)( > max(

} max = pos.GetInfo;)(

placeMax = pos;}

pos = pos.GetNext;)(}

return placeMax};

public static Node<int> MinInList)List<int> l(}

Node<int> pos = l.GetFirst;)( int min = pos.GetInfo;)(

Node<int> placeMin = pos; pos = pos.GetNext;)(

while )pos != null(}

if )pos.GetInfo)( < min(}

min = pos.GetInfo;)( placeMin = pos;

} pos = pos.GetNext;)(

} return placeMin};

הפעולה מחזירה הפניה לאיבר lהמכסימלי ברשימה

הפעולה מחזירה הפניה לאיבר lהמינימלי ברשימה

public static TwoLists Split) List<int> lst( } TwoLists t = new TwoLists)(; List<int> la = t.GetA)(; List<int> lb = t.GetB)(; Node<int> p = lst.GetFirst)(, placeMin, placeMax; while )!lst.IsEmpty)((}

placeMin = MinInList)lst(; placeMax = MaxInList)lst(;

la.Insert)null, placeMIn.GetInfo)((; lb.Insert)null, placeMax.GetInfo)((; lst.Remove)placeMax(; lst.Remove)placeMIn(; } return t; }

בניית צמד הרשימות:

שימוש בפעולת עזר אחת!הערה: פעמים את הערכים n/2אפשר לפתור בדרך אחרת: למצוא

הנותרים יש להעביר/ n/2, את laהמינימליים ולהעבירם לרשימה להעתיק

lbלרשימת המכסימליים