ABA


"חידה - מימוש רשימה דו-מקושרת עם מצביע אחד - פתרון."
גירסת הדפסה        
קבוצות דיון פיתוח, תיכנות ובניית אתרים נושא #15448 מנהל    סגן המנהל    מפקח   Winner    צל"ש   מומחה  
אשכול מספר 15448
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   20:11   27.08.09   
אל הפורום  
  חידה - מימוש רשימה דו-מקושרת עם מצביע אחד - פתרון.  
 
ערכתי לאחרונה בתאריך 04.09.09 בשעה 18:24 בברכה, Deuce
 
פתרון החידה
לצערי הרב, חידה שנייה שאף אחד לא מצליח לפתור (למעט דניאל שנתן לי פתרון).
הפתרון האלגנטי:
כמו שאמרתי, לכל אלמנט יהיה שדה DATA val ושדה int whereToGo שבעזרתו נצטרך לדעת לאן ללכת. השדה whereToGo יכיל בתוכו את XOR של האיבר לפני והאיבר אחריו, קרי:
XOR(next,prev)

עבור הרשימה עצמה, יהיה מצביע לאיבר הנוכחי (curr) ומצביע לאיבר אחד לפניו (prev); יהיה מעין זקיף 0 עבור NIL - לא נתייחס למקרי קצה. הרשימה ציקלית.

ברגע שאנחנו נמצאים על איבר מסויים ורוצים לזוז שמאלה אז:
נבצע XOR עם הערך של prev.whereToGo והערך של curr& (זה מביא לנו את הכתובת של הקודם ל-prev).
נעדכן את curr להיות prev.
נעדכן את prev להצביע על הכתובת שה-XOR החזיר.
ברגע שאנחנו נמצאים על איבר מסויים ורוצים לזוז ימינה אז:
נבצע XOR עם הערך של curr.whereToGo והערך של prev& (זה מביא לנו את הכתובת של העוקב ל-curr).
נעדכן את prev להצביע על curr.
נעדכן את curr לכתובת שהוחזרה מה-XOR.

באופן כזה אנחנו זזים על הרשימה ימינה/שמאלה ב-O של 1, אך משתמשים רק ב-n מצביעים (ועוד 2 מצביעים ברשימה עצמה). יש חסרונות למימוש זה כמו טיפול בזכרון. כמו כן אוספי זבל לא יודעים לנקות את זה כמו שצריך.

קטע מגניב של מימוש זה:
במידה ואנחנו רוצים להפוך את כיוון כל הרשימה אז ההצעה שלי לפחות היא פשוט לעדכן את 2 השגרות prev ו-next. אופרטור XOR סה"כ לא יודע מה אנחנו רוצים ולכן יש לנו שליטה מלאה בו. אם נגיד פשוט ש-nextTerm יתנהג כמו prevTerm ו-prevTerm יתנהג כמו nextTerm אז הרשימה מתהפכת.

תודה לכל המשתתפים.


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

שימו לב שניתן במימוש זה להוסיף איבר ב-O(1), למחוק איבר ב-O(n) בהנתן המפתח שלו ולמצוא איבר ב-O(n); יש חסרון מסויים כמו כן.

אפרט קצת יותר:
הרשימה תהיה דינמית לכל דבר. כלומר, בברירת מחדל אנו באיבר הראשון. נאפשר ללקוח את הפעולות nextTerm ו-prevTerm שמקדמות את הרשימה אחד קדימה ואחורה בהתאמה. במידה והרשימה שלנו למשל היא {1,2,3,4} וביצענו nextTerm פעמיים ואז Insert(5) אז הרשימה החדשה תהיה {1,2,3,5,4}. ביצוע Delete ימחק את האיבר הנוכחי ויחזיר אותנו איבר אחד קדימה או אחורה (לבחירתכם). אפשר לתכנן שהרשימה תהא ציקלית כדי לא לטפל במקרי קצה.
הרעיון לצמצם את כמות המשתנים מ-2n ל-n+c כאשר c מספר קבוע קטן מאוד של משתנים (במידה ואתם צריכים).

עוד קצת פירוט על ה-struct:
https://rotter.name/nor/prog/15448.shtml#15 "






                                שתף        
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד

  האשכול     מחבר     תאריך כתיבה     מספר  
  וינר לזוכה.. בהצלחה ! Nesher  27.08.09 20:21 1
  אני משער שאתה מדבר על שפות C++/C, כן? ldan192  27.08.09 21:11 2
     כן, על שפות שיש בהן מצביעים :) Deuce  27.08.09 21:13 3
         אז האמת היא שזה דיי פשוט... :) אבל אתן צ'אנס לאנשים פה ldan192  27.08.09 23:07 4
             דווקא לא כזה לטעמי אבל אם אתה אומר חח. Deuce  28.08.09 01:14 5
                 אני משער שצריך להשתמש ב-long ו-*char, אה? (בלי לספיילר יותר מדיי) ldan192  28.08.09 10:41 6
                     אמממ לא סתם לשרשר את המצביעים (: Deuce  28.08.09 15:23 8
                         אבל מותר לשמור INT-ים בנוסף במבנה הנתונים? בכל מקרה-גם בלי יש לי רעיון ldan192  28.08.09 17:44 10
                             מותר, אבל מספר קבוע של כאלו. Deuce  28.08.09 22:14 14
  מה כאילו שנתון לך VeNom  28.08.09 14:37 7
     הוספה זה לסוף/תחילת הרשימה - לא מעניין במיוחד. Deuce  28.08.09 15:25 9
         לא הבנתי את התוספת VeNom  28.08.09 19:08 12
             אבל היא לא דו כיוונית. Deuce  28.08.09 22:17 15
                 לא הבנת VeNom  29.08.09 11:03 21
                     אוקי, אבל זה לא סוג המימוש שאני מחפש. Deuce  29.08.09 20:03 24
                         שמע VeNom  30.08.09 12:14 28
  אני גם מכיר את החידה ולכן לא אענה עליה Net_Boy  28.08.09 18:45 11
     בהחלט, אני קצת מעמיק את הידע אז ראיתי אותה שם. Deuce  28.08.09 22:18 17
  אחרי העדכון זה בדיוק מה שחשבתי. לפי דעתי אפילו יש לי שיטה לוותר על ה-C ldan192  28.08.09 20:51 13
     c הזה יכול להסתכם באחד שניים. Deuce  28.08.09 22:18 16
         כן, ברור אחד, או שניים ליתר קריאות. אבל בעיניי גם זה לא ldan192  29.08.09 00:17 18
  טוב, אני אעבוד על משהו יותר מאוחר ואעדכן ldan192  29.08.09 00:23 19
     אפשר כמובן רעיון כללי, לא צריך לחפור על מימוש :) Deuce  29.08.09 03:24 20
         נה... אני פרפקציוניסט. נדפק לי אבל ה-VS! מנסה לתקן אותו |: ldan192  29.08.09 12:37 22
  בשביל להוכיח את הנקודה, יצרתי בסוף קוד בלי אף פויינטר ldan192  29.08.09 14:30 23
     אממ נראה שפשוט במקום פויינטרים השתמשת ב-long. Deuce  29.08.09 20:20 25
         תשמע, באותה מידה אני יכולתי להשתמש ב-ptr ל-next כרגיל ldan192  29.08.09 21:29 26
             אמממ ככל שיש יותר ידע, קשה לחזור לשורשים חח :) Deuce  29.08.09 23:35 27

       
Nesher  לחץ כאן להצגת דירוג המשתמש
חבר מתאריך 2.7.02
2 הודעות, 24 פידבק
   20:21   27.08.09   
אל הפורום  
  1. וינר לזוכה.. בהצלחה !  
בתגובה להודעה מספר 0
 


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   21:11   27.08.09   
אל הפורום  
  2. אני משער שאתה מדבר על שפות C++/C, כן?  
בתגובה להודעה מספר 0
 


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   21:13   27.08.09   
אל הפורום  
  3. כן, על שפות שיש בהן מצביעים :)  
בתגובה להודעה מספר 2
 






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   23:07   27.08.09   
אל הפורום  
  4. אז האמת היא שזה דיי פשוט... :) אבל אתן צ'אנס לאנשים פה  
בתגובה להודעה מספר 3
 


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   01:14   28.08.09   
אל הפורום  
  5. דווקא לא כזה לטעמי אבל אם אתה אומר חח.  
בתגובה להודעה מספר 4
 






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   10:41   28.08.09   
אל הפורום  
  6. אני משער שצריך להשתמש ב-long ו-*char, אה? (בלי לספיילר יותר מדיי)  
בתגובה להודעה מספר 5
 


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   15:23   28.08.09   
אל הפורום  
  8. אמממ לא סתם לשרשר את המצביעים (:  
בתגובה להודעה מספר 6
 
הרעיון שאם יש לך next ו-prev שכל אחת מצביע על כתובת בת k סיביות, אז במימוש שאני דורש אני רוצה משתנה אחד עם k סיביות.






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   17:44   28.08.09   
אל הפורום  
  10. אבל מותר לשמור INT-ים בנוסף במבנה הנתונים? בכל מקרה-גם בלי יש לי רעיון  
בתגובה להודעה מספר 8
 


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   22:14   28.08.09   
אל הפורום  
  14. מותר, אבל מספר קבוע של כאלו.  
בתגובה להודעה מספר 10
 






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
VeNom  לחץ כאן להצגת דירוג המשתמש
חבר מתאריך 7.6.02
7922 הודעות, 1 פידבק
   14:37   28.08.09   
אל הפורום  
  7. מה כאילו שנתון לך  
בתגובה להודעה מספר 0
 
   רשימה דו מקושרת(רשימה שמכילה שדה דאטא שדה נקסט שהוא פוינטר ושדה prev שהוא פוינטר?)
ואתה צריך לארגן מימוש של מבנה נתונים שיאפשר הוספה בפעולה אחת מחיקה וחיפוש בלינאריות?
אם כן זה די פשוט..אגב ההוספה אתה רוצה להוסיף לסוף הרשימה של הזמן או לתחילת הרשימה?


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   15:25   28.08.09   
אל הפורום  
  9. הוספה זה לסוף/תחילת הרשימה - לא מעניין במיוחד.  
בתגובה להודעה מספר 7
 
יודע מה - אני אעדכן את זה קצת.






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
VeNom  לחץ כאן להצגת דירוג המשתמש
חבר מתאריך 7.6.02
7922 הודעות, 1 פידבק
   19:08   28.08.09   
אל הפורום  
  12. לא הבנתי את התוספת  
בתגובה להודעה מספר 9
 
   אתה רוצה להקטין מ 2n ל n+c?
מה הכוונה?
אם אתה רוצה מימוש כזה אז פשוט מאוד נתון לך רשימה דו כיוונית.
תחזיק פוינטר לlast node כלומר לראש הרשימה.כמובן הפוינטר צריך להיות מאותו טיפוס של איבר ברשימה.
ואז הוספה בפעולה אחת זה פשוט pointer->next=new\malloc
pointer->data=what you wanted to add.
חיפוש איבר?
יש לך את שדה ה prev וזה יהיה לכל היותר לינארי אם תרוץ מהסוף עד שתמצא אותו.
לי נראה שאני מפספס משהו כי לממש כזה דבר זה מובן מאליו עוד לפני שלומדים מבנה נתונים..


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   22:17   28.08.09   
אל הפורום  
  15. אבל היא לא דו כיוונית.  
בתגובה להודעה מספר 12
 
אתה מפספס משהו.
הרשימה היא דו כיוונית.
הרעיון הוא שתהיה דינמית - אפשר יהיה לרוץ עליה כל פעם איבר אחד שמאלה ואיבר אחר ימינה.
שים לב שאם בכל שלב למשל תשמור את שני האיברים מצידך אז זה לא יספיק כי אם אני אזוז שמאלה אז אני לא אדע מי נמצא שניים משמאלי.

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






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
VeNom  לחץ כאן להצגת דירוג המשתמש
חבר מתאריך 7.6.02
7922 הודעות, 1 פידבק
   11:03   29.08.09   
אל הפורום  
  21. לא הבנת  
בתגובה להודעה מספר 15
 
   אני שומר את המצביע שתמיד יצביע לאיבר האחרון ברשימה.
כל פעם שאני מוסיף איבר אני מעדכן את המצביע.
ככה אני נמצא בסוף הרשימה תמיד.
הכנסה=פעולה אחת.
חיפוש=לינארי וגם הכנסה תהיה לינארית.
אני יכול ללכת לשדה ה prev\next\data באמצעות המצביע כי הוא מאותו טיפוס.
ברור שהרשימה תהיה דינמאית,אבל זה לא משנה כי אני תמיד מעכדן את המצביע שיצביע לאיבר האחרון שהוכנס.
במידה ואיבר הוכנס לאמצע הרשימה המצביע לא משתנה.


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   20:03   29.08.09   
אל הפורום  
  24. אוקי, אבל זה לא סוג המימוש שאני מחפש.  
בתגובה להודעה מספר 21
 
אני רוצה שהמבנה יתמוך בפעולות:

Insert(x) - insert a key x between the current place to his successor in list
nextTerm - updates pos position into the next pos
prevTerm - updates pos position into the last pos

כולן צריכות להיות ב-O של 1. הרשימה היא ציקלית.
דוגמא לאוסף פעולות:

Insert(5)
Insert(10)
Insert(15)
{5,15,10}
Insert(1000)
{5,1000,15,10}
nextTerm
Insert(90)
{5,1000,90,15,10}
prevTerm
prevTerm
Insert(13)
{5,1000,90,15,10,13}

זה הרעיון.






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
VeNom  לחץ כאן להצגת דירוג המשתמש
חבר מתאריך 7.6.02
7922 הודעות, 1 פידבק
   12:14   30.08.09   
אל הפורום  
  28. שמע  
בתגובה להודעה מספר 24
 
   אני כנראה לא תופס אותך.
מה הבעיה לשים מצביע של הטיפוס ל next node ולגמור את הסיפור?
תקרא לו nextnode נגיד.
הוספה תהיה ב פעולה אחת:
curr->next=addnewnode(send him the nextnode as a parameter so he can update the the current node's next node and connect the list).
פעולה של nextterm\prevterm
היא גם בפעולה אחת..ע"י קידום המצביע הנוכחי.
בגדול כדי להוסיף איבר צריך לשמור מצביע לתא ה next
של הnode
הנוכחי,אחרת אתה נדפק עם משהו שהוא בעצם לא רשימה.
ולא חייב שהיא תהיה ציקלית.
או ששוב פעם אני לא איתך..


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Net_Boy  לחץ כאן להצגת דירוג המשתמש
חבר מתאריך 1.4.02
17151 הודעות, 1 פידבק
   18:45   28.08.09   
אל הפורום  
  11. אני גם מכיר את החידה ולכן לא אענה עליה  
בתגובה להודעה מספר 0
 
   היא הופיעה בספר introduction to algorithms
חידה נחמדה מאד...


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   22:18   28.08.09   
אל הפורום  
  17. בהחלט, אני קצת מעמיק את הידע אז ראיתי אותה שם.  
בתגובה להודעה מספר 11
 
אפילו למדתי להוכיח את שיטת האב






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   20:51   28.08.09   
אל הפורום  
  13. אחרי העדכון זה בדיוק מה שחשבתי. לפי דעתי אפילו יש לי שיטה לוותר על ה-C  
בתגובה להודעה מספר 0
 


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   22:18   28.08.09   
אל הפורום  
  16. c הזה יכול להסתכם באחד שניים.  
בתגובה להודעה מספר 13
 
לא יותר חח.






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   00:17   29.08.09   
אל הפורום  
  18. כן, ברור אחד, או שניים ליתר קריאות. אבל בעיניי גם זה לא  
בתגובה להודעה מספר 16
 
חובה (משחק עם XOR-ים)


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   00:23   29.08.09   
אל הפורום  
  19. טוב, אני אעבוד על משהו יותר מאוחר ואעדכן  
בתגובה להודעה מספר 0
 
ערכתי לאחרונה בתאריך 29.08.09 בשעה 00:30 בברכה, ldan192
 


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   03:24   29.08.09   
אל הפורום  
  20. אפשר כמובן רעיון כללי, לא צריך לחפור על מימוש :)  
בתגובה להודעה מספר 19
 






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   12:37   29.08.09   
אל הפורום  
  22. נה... אני פרפקציוניסט. נדפק לי אבל ה-VS! מנסה לתקן אותו |:  
בתגובה להודעה מספר 20
 


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   14:30   29.08.09   
אל הפורום  
  23. בשביל להוכיח את הנקודה, יצרתי בסוף קוד בלי אף פויינטר  
בתגובה להודעה מספר 0
 
אחרי התקנה מחדש של ה-VS הבעיה הסתדרה :}

https://rotter.name/User_files/nor/4a99113133e16a04.txt

תשמרו את הקובץ כקובץ c.


כמובן ש-long שוקל כמו פויינטר ככה שאין טעם בקוד.
אבל הרעיון עובד... סה"כ משחק פויינטרים פשוט מאוד.

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


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   20:20   29.08.09   
אל הפורום  
  25. אממ נראה שפשוט במקום פויינטרים השתמשת ב-long.  
בתגובה להודעה מספר 23
 
תיאורתית יכולת לשמור פשוט את הכתובות ולגשת אליהן דרך *.
זה לא ממש מה שרציתי.
אני רוצה שממש תשתמש במשתנה אחד ולא בשניים. ה-prev וה-next יתחלפו במשתנה אחד בודד עם מספר ביטים כמספר ביטים של כתובת בזכרון (ולצורך הנחה היא תהיה int). כלומר לכל חוליה יש לך רק משתנה אחד מסוג int (וב-data פשוט מאוחסן ה-data, לא נוגעים בו).






                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
ldan192 
חבר מתאריך 14.9.08
95119 הודעות
   21:29   29.08.09   
אל הפורום  
  26. תשמע, באותה מידה אני יכולתי להשתמש ב-ptr ל-next כרגיל  
בתגובה להודעה מספר 25
 
וב-int לאופסט תוך כדי כיוון הקצאות הזכרון שיהוו 7 ביטים והסתמכות על הידע במערכות הפעלה שלא יתכן שיוקצה זכרון מתחת להפרש הזה (או מקסימום משחקים עם XOR-ים בשביל לדחוס long ב-int).
אבל זה כמעט זהה למה שכתבתי פה.

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


בברכה,
עידן


                                                         (ניהול: מחק תגובה)
מכתב זה והנלווה אליו, על אחריות ועל דעת הכותב בלבד
Deuce 
חבר מתאריך 1.9.08
6225 הודעות
   23:35   29.08.09   
אל הפורום  
  27. אמממ ככל שיש יותר ידע, קשה לחזור לשורשים חח :)  
בתגובה להודעה מספר 26
 
כל מה שאתה אומר זה נכון אבל אני לא מכוון לדרך כזאת מסובכת, אלא למשהו סה"כ אלגנטי ויפה.

נניח שכתובת בזכרון מיוצגת על ידי k סיביות, ונניח שחייבים את כל k הסיביות האלה כדי לגשת אליה. נניח ש-k הסיביות האלה הן sizeof(int). כעת אני רוצה שבעזרת משתנה אחד שיהיה מטיפוס int תוכל ללכת ימינה ושמאלה, במקום שני משתנים כאלה.


typedef struct elem
{
int secret;
DATA val;
} elem;

זה מה שיש לתא עצמו.
חוץ מזה יהיה נניח:

typedef struct list
{
elem* head;
elem* last; // אולי
ועוד מספר קבועים לשימושך
{

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






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

תגובה מהירה  למכתב מספר: 
 
___________________________________________________________________

___________________________________________________________________
למנהלים:  נעל | תייק בארכיון | מחק | העבר לפורום אחר | מחק תגובות | עגן אשכול
       



© כל הזכויות שמורות ל-רוטר.נט בע"מ rotter.net