הזיכרון כבר אינו "שייך" לתוכנית שלך המערכת הפעלה יכולה לתת אותו לתוכנה אחרת.

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

אז איך הוא פנוי לתוכניות אחרות אם התוכנית שלי עוד משתמשת בו?

ולמה ZELIG אמר פה שאסור להשתמש בזכרון ששוחרר? אם אני משתמש בו והכל עובד בסדר גמור...

אה ודרך אגב מה הפונקציה STRDUP בדיוק עושה? -היא לוקחת מחרוזת, מקצה מקום בגודל מתאים בזכרון, מעתיקה אליו את המחרוזת ומחזירה מצביע לתחילת המחרוזת?? אני רוצה לוודא שהבנתי בדיוק.

אה תודה, סוף סוף הבנתי מה זה....

אבל לא נראה כזה יעיל, עדיף כבר את ההדפסות עזר שלי, יותר עוזרות...

1) התוכנית שלך "הודיעה" ע"י free שהיא לא תשתמש יותר במקום שהקצאת מקודם.

2) אסור, והסבירו לך הודעה אחת מעלי.

3) הפונ שייכת לC++ ולא לC. אל תשתמש בה. עדיף שתיצור פונ משלך. וכן, זה מה שהיא עושה.

4) עניין של נוחות. גם אני משתמש לפעמים בהדפסות(בשביל דברים קטנים).

וכשאתה כותב גרסה משלך ל-strdup, אל תשכח להקצות strlen+1 בתים למחרוזת החדשה.

נכון. התו הנוסף הוא '\0' שמסמל סוף מחרוזת.

כן זה בדיוק מה שאני עושה תמיד.

יש לי עוד בעיה כשאני מגדיר קבוע נגיד:

define std 5;

אז כשבהמשך התוכנית אני מגדיר מערך בעזרת הקבוע:

int array[std] a

זה לא נותן לי, למה לא?

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

קודם כל, אתה צריך סולמית לפני ה-define. חוץ מזה - בלי נקודה-פסיק.

define זה פקודה ל-preprocessor שרצה לפני הקומפיילר, והיא פשוט מחליפה את הערך בערך ששמת. כלומר, אם הגדרתי

#define std 5;
int array[std];

זה שקול ל:

int array[5;];

וזו כמובן שגיאה.

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

טוב,נשארה הבעיה עם הMERGE SORT...

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

מספיק שתפצל את המערך שלך כל פעם ל- 2 עד שתגיע למערך בגודל 1 ממויין(תמיד). אחר כך תאחד אותם.

אבל איך אני מאחד? הרי כל פעם שאני קורא לפונקציה עם המערך היא תשכפל את המצביע אליו הרי. וגם כשהמערך מתפרק למערכים בעלי איבר אחד- איך אני מסדר אותם בצורה כזאת שיהיה לפי הסדר?

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

אתה חייב להשתמש במספר מערכים.

בסך הכל צריך מערך עזר אחד בלבד (בגודל המערך המקורי).

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

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

תיצור שמאחדת 2 מערכים ממויינים לתוך מערך אחר שגם הוא יהייה ממויין בזמן ריצה ליניארי.

אתה צריך לשמור 2 אינדקסים-

1)של המערך הראשון

2)שם המערך השני

3) אתה לא צריך לשמור אינדקס למערך החדש מכיוון שזה הסכום של הקודמים.

כעיקרון, אתה צריך לעשות לולאה בתוך לולאה. ממבט ראשון זה יהייה o(n*m) אבל אם תחקור את זה יותר לעומק, תשים לב שמספר האיטרציות של הלולאה החיצונית תלוי בפנימית, ולכן זה יהייה o(m+n).

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

בבקשה:

void merge_sorted(int* a1, int* a2, int size, int* out) {

 int i1 = 0;
 int i2 = 0;
 int j = 0;

 while (i1 < n && i2 < n) {
  if (a1[i1] < a2[i2]) {
   out[j] = a1[i1];
   ++i1;
  } else {
   out[j] = a2[i2];
   ++i2;
  }
  ++j;
 }

 // Since we only went over one of the array completely,
 // Finish the rest of the other array
 for ( ; i1 < n ; ++i1, ++j) 
  out[j] = a1[i1];
 }

 for ( ; i2 < n ; ++i2, ++j) 
  out[j] = a2[i2];
 }


}

וזאת בהנחה ש-a1,a2 הם מערכים בגודל size, ו-out הוא מערך בגודל size*2.

תודה.

וראיתי שרשמת שם משתנה n שלא מוגדר אז אני מניח שהכוונה ל-size.

אבל זה רק הקוד של איחוד שני מערכים, איפה הפונקציה עצמה, שמקבלת מערך ומחלקת אותו לשניים כל פעם, ואז ממיינת אותו? הנה כמו פה:

http://en.wikipedia.org/wiki/Merge_sort

אבל אני לא מבין את זה מספיק כדי לממש את זה ב-C...