תכנות בשפת C תרגול 11 רשימות מקושרות מבנים 15.05.2011

typedefאופרטור ה- ניתן להגדיר טיפוס חדש על ידי פקודת typedef שתבניתה היא: typedef existing_type new_type ; המהדר יחליף את הטיפוסexisting_type בטיפוס החדש new_type. לדוגמה: typedef int* pint; pint p,q; int* r; r = p; השימוש ב-typedef מאפשר להפוך את הקוד לקריא יותר מבחינת ההקשר.

struct - מבנה טיפוס המאגד עצמים מטיפוסים שונים (או זהים) בתוך רשומה אחת. תחביר: struct name_of_struct {     field1; field2; etc. }; דומה למערך בכך ששניהם יכולים לאגד מספר נתונים , אך במבנה יש חופש בבחירת טיפוסי הנתונים: struct address {     char city[20];     char street[20];     int num_house;     long code_area; }; אין מניעה שאחד השדות יהיה בעצמו מבנה

תחביר struct ע"מ להכריז על משתנה מסוג מבנהaddress יש לכתוב: איתחול: struct address x; איתחול: struct address add = {"migdal Haemek", "Harazim", 5, 23028}; ניתן להשתמש ב- typedef כדי להקל על שימוש ב- struct : typedef struct some_name { char alias[20]; char username [20]; char password[10]; int numberOfFriends; } facebook_record; אפשר להחליף כל מופע של facebook_record בקוד ב- struct some_name , ולהיפך

תחביר struct (המשך) דרך אחרת: struct some_name { char alias[20]; char username [20]; char password[10]; int numberOfFriends; }; typedef some_name facebook_record; struct ניתן לשימוש כפרמטר לפו' או כערך החזרה של פו', ממש כמו כל טיפוס אחר. ניתן להגדיר מצביע למבנה: facebook_record* p; ניתן להגדיר מערך של רשומות: facebook_record records[10];

גישה לשדות ב- struct כדי לגשת לשדות, קיימים שני אופרטורים: נקודה (.) וחץ (->) . אופרטור הנקודה מאפשר גישה לשדות בתוך משתנה מטיפוס המבנה. facebook_record d; strcpy(d.username, “david hasholet”); d.numberOfFriends = 501; אופרטור החץ מאפשר גישה לשדות בתוך משתנה מטיפוס מצביע למבנה. facebook_record* d = (facebook_record*)malloc( sizeof(facebook_record) ); strcpy(d->username, “david hasholet”); d->numberOfFriends = 501;

רשימות מקושרות רשימה מקושרת – שרשרת של רשומות. כל רשומה מכילה מצביע לרשומה הבאה או NULL (עבור הרשומה האחרונה). בניגוד למערך, אין גישה מיידית לכל איבר, אלא על-ידי סריקה של הרשימה עד שמגיעים לאיבר המבוקש; היתרון לעומת מערך – הוספה ומחיקה יעילה של איברים. לדוגמה: typedef struct node node;   struct node { int val; /* --> data field - can be other types*/ struct node *next; /* --> next field */ }; בדרך כלל מגדירים פונקציות להוספה, מחיקה וסריקה של רשימה בהתאם לצרכי המתכנת.

פונקציות בסיסיות ברשימות node* make_node(int value) { node* tmp = (node*)malloc(sizeof(node)); tmp->next = NULL; tmp->val = value; return tmp; } void insertAfter(node * p, int data) { // assume p is not NULL node *q = make_node (data); q->next = p->next; p->next = q; void deleteAfter(node * p) { // assume p is not NULL node *q = p->next; if (q != NULL) { p->next = q->next; free(q);

פונקציה למחיקת רשימה void deleteLinkedList(node * head) { if (head != NULL) { while (head->next != NULL) deleteAfter(head); free(head); }

שאלה 1 להלן הגדרה: typedef struct node { int val; struct node *next; לדוגמה, אחרי הקריאה ל- void upper_list(node* first) הרשימה העליונה תהפוך לתחתונה:

שאלה 1 (המשך) השלימו את קטע הקוד הבא: void upper_list(node* first) {   void upper_list(node* first) { node *temp; if( ?? 1 ?? ) return; while(?? 2 ??){ if( ?? 3 ??>= ?? 4 ??){ temp = ?? 5 ??; ?? 6 ?? ; free(temp) ; } else ?? 7 ?? ;

שאלה 1 (פתרון) void upper_list(node* first) { node *temp; if( !first ) return; while(first->next){ if( first->val>=first->next->val){ temp = first->next; first->next=first->next->next ; free(temp) ; } else first=first->next;

שאלה 2 בהתיחס להגדרת הצומת משאלה מס' 1, השלם את החלק החסר בקוד הבא כך שהפונקציה תשכפל כל צומת מס' פעמים השווה לערכו של משתנה ה- val שלו ואז תוסיף את הצמתים החדשים לרשימה ישר אחרי הצומת ממנו הם שוכפלו. void multiply(node* head) { node *temp; int i;   while(head) { temp = head -> next; for(i=0; i< ?? 1 ??; i++) head->next = ?? 2 ?? ; ?? 3 ?? = head -> val; head = ?? 4 ?? ; } ?? 5 ?? = ?? 6 ?? ; head = ?? 7 ??; לדוגמה, אחרי הביצוע של הפונקציה הנ"ל הרשימה העליונה תהפוך לתחתונה:

שאלה 2 (פתרון) void multiply(node* head) { node *temp; int i; while(head) temp = head -> next; for(i=0;i<head->val-1; i++) head->next = (node*)malloc(sizeof(node)); //create head->next->val = head -> val; // copy the value head = head->next ; //move to the next node } head->next = temp ; //connect to the next node in the //original list head = temp; //move to the next node in the original //list.

שאלה 3 void trim(node* lst) { node *aux; while( ?? 1 ?? && ?? 2 ??){ if(lst->val == ?? 3 ??){ aux = ?? 4 ?? ; lst->next = ?? 5 ?? ; free( ?? 6 ?? ); } else lst = ?? 7 ?? ; בהתיחס להגדרת הצומת משאלה מס' 1, השלם את החלק החסר בקוד הבא כך שהפונקציה תמחק את כל המופעים הכפולים של ערכים ברשימה מקושרת ממוינת (ותשאיר רק אחד מהם).

שאלה 3 (פתרון) void trim(node* lst) { node *aux; while(lst!=NULL && lst->next!=NULL){ if(lst->val == lst->next->val){ aux = lst->next ; lst->next = lst->next->next ; free(aux); } else lst = lst->next ;

תכנית לדוגמא – בדיקת סוגריים: תוכנית זו מקבלת מחרוזת המכילה סוגריים מסוגים שונים ובודקת אם הסוגריים מתואמות. נשים לב: יש צורך במבנה נתונים (שנקרא "מחסנית") כי כאשר עוברים על המחרוזת, יש לזכור את כל הסוגרים שנפתחו, הסוגים והסדר. עדיף להשתמש ברשימה מקושרת ולא במערך כאן, כי אפשר לטפל במחרוזת בכל אורך (בלי שנצטרך לבצע dynamic memory reallocation) כעת נבחן את התכנית בשלמותה (בקובץ המצורף parenthesis-matching.c)