1. תכנות תרגול 12 שבוע : 14.6.06

2. הקצאת זיכרון דינאמית הזיכרון המקסימאלי ששימש את התוכנית שלנו עד היום היה קבוע מראש. לפני הרצת התוכנית, לאחר שהתוכנית עברה את שלב התרגום, כל המערכים שבתוכנית גודלם נקבע ואינו ניתן לשינוי במהלך ריצת התוכנית ! בעיות אפשריות : אם הגדרנו מערך בגודל 100 לשמור את ציוני כל הסטודנטים וכעת מגיע סטודנט נוסף מה נעשה ? התוכנית כבר כתובה ולא ניתן לשנות את גודל המערך !

3. הקצאת זיכרון דינאמית C מאפשרת לנו להקצות זיכרון תוך כדי ריצת התוכנית וכך להגדיר מערכים ומבנים אחרים בצורה דינאמית int main() { int a[10]; a[6] = 7; } 10 ints int main() { int *a; a = (int*) malloc(sizeof(int) * 10); a[6] = 7; } a 10 ints 6024

4. שחרור זיכרון שהוקצה דינאמית כל שטח זיכרון שהוקצה ע " י המתכנת צריך להיות משוחרר בסיום השימוש בו. לכן חייבים תמיד להחזיק את כתובת האזור שהוקצה על מנת שנוכל לשחרר אותו בסיום השימוש. כל שטח זיכרון שהוקצה ע " י המתכנת צריך להיות משוחרר בסיום השימוש בו. לכן חייבים תמיד להחזיק את כתובת האזור שהוקצה על מנת שנוכל לשחרר אותו בסיום השימוש. int main() { int *a; a = (int*) malloc(sizeof(int) * 10); a[6] = 7; free(a); } a 6024

5. הפונקציות נמצאות ב - stdlib.h הפונקציות נמצאות ב - stdlib.h void *malloc(size_t size); void *malloc(size_t size); –Allocate size bytes. Successful call return base address; otherwise NULL is returned. void *calloc(size_t n,size_t size_el) void *calloc(size_t n,size_t size_el) –Allocate an array on n elements each in size of size_el. Each bit is initialized to zero. Successful call return base address; otherwise NULL is returned. void free(void *ptr) void free(void *ptr) –Deallocate the memory pointed by ptr which must be a base address of previously allocated memory void *realloc(void *,size_t size) void *realloc(void *,size_t size) –Reallocate a memory block of size size.

6. רשימות מקושרות ישנו מבנה נתונים אשר מאפשר ישנו מבנה נתונים אשר מאפשר לנו לבצע את הוספת האיברים בצורה נוחה יותר. מבנה זה נקרא רשימה מקושרת. איבר מידע מצביע לאיבר מצביע לראש הרשימה איבר מידע מצביע לאיבר איבר מידע מצביע לאיבר איבר מידע מצביע לאיבר איבר מידע מצביע לאיבר 5 71 8

7. struct list { int data; int data; struct list *next; struct list *next;}; typedef strcut list Item; מידע מצביע לאיבר פעולות על הרשימה : יצירה והריסה של רשימה ספירת מספר האיברים ברשימה חיבור שתי רשימות מחיקה / הוספה של איבר לרשימה הדפסת רשימה

8. רשימות מקושרות ב -C  נחזיק מצביע אשר יהיה מצביע לראש הרשימה וישב ב main-.  תהיה לנו פונקצית הוספה אשר תוסיף איברים לרשימה בסוף הרשימה.  הפונקציה תדע לקבל מצביע לראש הרשימה וערך להוספה ותוסיף את האיבר בסוף הרשימה.

9. איבר מידע מצביע לאיבר 3 איבר מידע מצביע לאיבר 7 איבר מידע מצביע לאיבר 5 רשימות מקושרות ב -C int main() { Item *L_head = NULL; L_head = Add(L_head,5); L_head = Add(L_head,3); L_head = Add(L_head,7); } מצביע לראש הרשימה

10. Item* Add(Item* L_head, int value) { Item* L_tail = L_head; Item* L_tail = L_head; Item* I_new = malloc(sizeof (Item)); Item* I_new = malloc(sizeof (Item)); I_new->value = value; I_new->value = value; I_new->next = NULL; I_new->next = NULL; if (L_tail == NULL) return I_new; while (L_tail->next != NULL) L_tail=L_tail->next; L_tail=L_tail->next; L_tail->next = I_new; L_tail->next = I_new; return L_head; return L_head;}

11. איבר מידע מצביע לאיבר 3 איבר מידע מצביע לאיבר 7 איבר מידע מצביע לאיבר 5 רשימות מקושרות ב -C int main() { Item *L_head = NULL; … L_head = Delete(L_head,3); } מצביע לראש הרשימה

12. Item *Delete(Item * head,int value) { Item* curr = head; Item* prev = head; if (curr->value == value) { curr = curr->next; free(head); return curr; } האיבר למחיקה הוא הראשון

13. while (curr != NULL) { if (curr->value == value) { prev->next = curr->next; free(curr); return head; } prev = curr; curr = curr->next; } return head; } חיפוש ומחיקת איבר

14. void PrintList(Item *head) { if (head == NULL) { printf("\n"); return; } else { printf("%d ",head->data); PrintList(head->next); return; } הדפסת רשימה

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

16. int Count(Item * L) { int counter=0; while (L != NULL) { counter++; L=L->next; } return counter; } int CountR(Item * L) { if (L == NULL) return 0; return 1 + CountR(L->next); }

17. כתוב פונקציה המקבלת מצביעים לשתי רשימות מקושרות ומחברת אותן. כתוב פונקציה המקבלת מצביעים לשתי רשימות מקושרות ומחברת אותן. איבר מידע מצביע לאיבר 3 איבר מידע מצביע לאיבר 7 איבר מידע מצביע לאיבר 5 רשימה 1 איבר מידע מצביע לאיבר 3 איבר מידע מצביע לאיבר 5 רשימה 2 איבר מידע מצביע לאיבר 3 איבר מידע מצביע לאיבר 7 איבר מידע מצביע לאיבר 5 איבר מידע מצביע לאיבר 3 איבר מידע מצביע לאיבר 5

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

19. Item* Meld(Item* L1,Item* L2) { Item* L1_head = L1; if (L1 == NULL) return L2; if (L2 == NULL) return L1; while (L1->next != NULL) L1=L1->next; L1->next = L2; return L1_head; }

20. רקורסיות חישוב עצרת n ! = n* (n-1) * … * 1 int factorial(int n) { if (n==1) return 1; return n*factorial(n-1); } int factorial(int n) { int fact =1 while (n >= 1) { fact *=n; n--; } return fact; } n ! = n * (n-1) ! 0 ! = 1

21. רקורסיות תרגיל : כתבו פונקציה המחשבת את הסכום Sum(n) = sum(n-1) + n Sum(1) = 1 רקורסיה

22. פתרון int sum(int n) { if (n==1) return 1; return n+sum(n-1); }

23. רקורסיות חישוב חזקה ברקורסיה double power(int x, int y) { if (y == 0) return 1; return x * power(x, y -1); }

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

25. רקורסיות פתרון int mul(int x,int y) { if (y==1) return x; return x+mul(x,y-1); }

26. רקורסיות פתרון int div(int x,int y) { if (y>x) return 0; return 1 + div(x-y,y); }

27. void reverse_array(int *begin, int *end) { while (begin < end) { swap(begin, end); begin++; end--; } reverse_array(my_arr, my_arr + SIZE -1); הפיכת מערך beginend 31 1 35 7

28. פתרון רקורסיבי הפיכת מערך void reverse_array(int array[], int size) { int i; for (i = 0; i < size/2; i++) swap(&array[i], &array[size - 1 - i]); }