1. Engineering Programming A
תרגול 10
מבנים ורשימות מקושרות
Introduction to C - Fall Amir Menczel

2. מטרת התרגול
Typedef
Structures
Linked list

3. typedef פקודת typedef:
typedef existingType newType;
המהדר יתייחס ל-newType כאל existingType - כלומר אם נגדיר משתנה מהטיפוס החדש, המהדר יתייחס אליו כאל משתנה שהוגדר לפי הטיפוס הישן. לדוגמא:
typedef int* pint;
pint p;
int *q;
משמעות: p ו-q שניהם הם משתנים מטיפוס int* מכיוון שהגדרנו את pint כ- int*.
השימוש ב-typedef מאפשר להפוך את הקוד ליותר קריא מבחינת ההקשר. השימוש העיקרי ב-typedef הוא בד"כ בעת הגדרת מבנים.

4. structures
מבנה (struct) הוא טיפוס אשר יכול להכיל מספר רב של נתונים מטיפוסים שונים. המבנה מורכב ממשתנים, שלכל אחד מהם קוראים שדה. ניתן לומר שמבנה דומה למערך בכך ששניהם יכולים לאגד מספר נתונים, אך מבנה נותן לנו גם חופש בבחירת טיפוסי הנתונים ,כלומר מבנה יכול להכיל גם float, int, double ועוד בעת ובעונה אחת תחת משתנה אחד. התבנית של מבנה: struct nameOfStruct { fields }; בהגדרת המבנה יש לכתוב את המילה השמורה struct ולאחר מכן את שם המבנה שבחרנו. חשוב ששמו של המבנה יהיה משמעותי בדיוק כמו בבחירת שמות למשתנים. בתוך הסוגריים יש לרשום את המשתנים ובסוף נקודה-פסיק.

5. structures
לדוגמא: struct address { char city[20]; char street[20]; int houseNum; }; יצרנו מבנה של "כתובת מגורים" הכולל: שם עיר ורחוב - מחרוזות בעלות 20 תווים, ומספר בית - משתנה מסוג int. כעת נצהיר על משתנה מהטיפוס "כתובת מגורים": struct address addr; שימו לב שיותר נוח להשתמש ב-typedef באופן הבא: typedef struct address address; ורק אז להגדיר את משתנה ה-"כתובת מגורים" כך: address addr;

6. structures
אופרטור הנקודה: כשנרצה לגשת לשדות של המשתנה addr ולעדכן אותם, נוכל לעשות זאת על ידי שימוש באופרטור הנקודה (.). לדוגמא, נציב את המספר 5 בשדה של מספר הבית באופן הבא: addr.houseNum = 5; כך ניתן לעדכן ולשנות את השדות. ניתן להצהיר על מספר משתנים מטיפוס מבנה בשורה אחת כמו שהצהרנו על משתנים פשוטים, לדוגמא: address addr1, addr2, addr3; כמו כן ניתן לאתחל מבנים כפי שאתחלנו מערך: address addr = {"Tel Aviv", "Menachem Begin", 132}; ניתן גם לבצע השמה בין מבנים, בצורה הבאה : addr1=addr2; נסכם ונאמר כי ניתן לבצע את כל הפעולות שביצענו במשתנים פשוטים על מבנה באותו אופן (הצבה כארגומנט בפונקציה, הצהרה וכו').

7. structures
אופרטור <- : האופרטור <- מאפשר גישה לשדה של מבנה כלשהו ממצביע למבנה. לדוגמא, נגדיר מצביע למבנה address, pAddress: address addr, *pAddr; pAddr = &addr; נוכל לגשת לשדה houseNum של המבנה ע"י כתיבת: addr.houseNum = 3; או: pAddr->houseNum = 3; (*pAddr).houseNum = 3;

8. structures
מבנה כפרמטר של פונקציה: נראה שני סוגים של העברת מידע האגור במבנים אל פונקציה כפרמטר - האחד העברה לפי כתובת והשני לפי תוכן. תרגיל 1: כתוב תכנית אשר מכילה פונקציה שקולטת לתוך מבנה שם וגיל של אדם, ובאמצעות פונקציה נוספת מדפיסה אותם.

9. structures
#include <stdio.h> typedef struct person { char name[20]; int age; } person; // by reference void getDetails (person *p) printf ("Enter name: "); gets (p->name); printf ("Enter age: "); scanf ("%d", &(p->age)); } //by value void printDetails (person p) printf("name: %s\n ", p.name); printf("age: %d\n ", p.age); void main() person pr; getDetails (&pr); printDetails (pr);
הסבר:
בפונקצית main() יש מבנה מסוג person, pr, ונניח שכתובת הזיכרון ממנה הוא מתחיל היא 1000.
כשנפעיל את הפונקציה getDetails, נרצה שהיא תוכל לשנות את המבנה, ולכן נעביר לפונקציה את הכתובת של המשתנה pr. לפיכך, הפרמטר של הפונקציה getDetails צריך להיות כתובת - כלומר מצביע.

10. structures מבנה כערך המוחזר על ידי פונקציה:
כאשר אנו מעוניינים לקלוט נתוני מבנה, לפעמים נעשה זאת בעזרת פונקציה המחזירה מבנה. בהצהרה על הפונקציה יש לרשום:
struct nameOfStruct nameOfFunction(arguments);
תרגיל 2:
שנה את הפונקציה getDetails מהתכנית הקודמת כך שתחזיר מבנה, ועדכן את ה-main בהתאם.

11. structures
Person getDetails(){ Person pers; printf ("Enter name: "); gets (pers.name); printf ("Enter age: "); scanf ("%d", &(pers.age)); return pers; } void main(){ Person pr; pr=getDetails(); printDetails (pr);

12. structures
מערך של מבנים: ניתן ליצור מערך של מבנים בדיוק כמו בהצהרת מערך רגיל. לדוגמא: person pr[3]; יוצר מערך של שלושה משתנים מטיפוס person . כדי לגשת לשדותיו יש לפנות קודם לאיבר במערך שבו אנו מעוניינים - לדוגמא, עבור השדה name באיבר השני של המערך, נרשום: pr[1].name תרגיל 3: שנה את התכנית הקודמת כך שתעבוד עם מערך של מבנים.

13. structures
#include <stdio.h> typedef struct person{ char name[20]; int age; } person; void getDetails (person p[],int size){ int i; for (i=0; i<size; i++) { printf ("Enter name: "); gets (p[i].name); printf ("Enter age: "); scanf ("%d", &(p[i].age)); } void printDetails (person p[],int size){ for (i=0; i<size; i++) { printf("name: %s\n ", p[i].name); printf("age: %d\n ", p[i].age); void main(){ person pr[3]; getDetails (pr,3); printDetails (pr,3);

14. רשימות משורשרות typedef struct address { char city[20];
הקדמה - מבנה מקונן:
שדות של מבנה יכולים להיות בעצמם מבנה לדוגמא:
typedef struct address {
char city[20];
char street[20];
int houseNum
} address;
typedef struct person
char name[20];
int age;
address addr;
} person;
נניח כי אנו מצהירים על משתנה מסוג person: person p;
כדי לגשת לשדה age נרשום : p.age כדי לגשת לשדה city נרשום: p.addr.city כלומר ראשית ניגש לשדה addr שהוא גם מטיפוס מבנה וממנו ניגש לשדות שלו שוב על ידי אופרטור הנקודה.

15. רשימות משורשרות typedef struct node{ int value; node *next; } node;
רשימות מקושרות - הגדרה ותכונות:
רשימה מקושרת – שרשרת של מבנים. כל מבנה מכיל מצביע למבנה הבא או NULL (עבור המבנה האחרון אשר לא מצביע על המבנה הבא - כי אין כזה).
לאיבר שנמצא בתחילת הרשימה נהוג לקרוא "עוגן".
בניגוד למערך, אין גישה מיידית לכל איבר ברשימה באמצעות סוגריים מרובעות [], אלא באמצעות סריקה של הרשימה עד שמגיעים לאיבר המבוקש.
היתרון לעומת מערך – הוספה ומחיקה יעילה של איברים. כלומר – אם נרצה למחוק איבר מאמצע מערך, נהיה חייבים ליצור עותק חדש של המערך כולו. ברשימה כל מה שנצטרך לעשות זה למחוק את האיבר שמיועד להימחק, ולקשר בין שני האיברים שמסביבו. זהו חיסכון משמעותי ביותר מבחינת זמן ריצה.
typedef struct node{
int value;
node *next;
} node;

16. רשימות משורשרות תרגיל 4:
כתוב פונקציה countDifItems(node *list) int המקבלת כארגומנט מצביע לרשימה מקושרת ומחזירה את מספר הערכים השונים (value) שברשימה.
לדוגמה, עבור הרשימה באה:
countDifItems(head) שווה 3.

17. רשימות משורשרות
int countDifItems(node *list) { node *temp; int found, count=0; while(list){ found = 0; temp = list; while(temp){ if(temp->value == list->value) found++; temp = temp->next; } if(found==1) count++; list = list->next; return count;

18. רשימות משורשרות
תרגיל 5:

19. רשימות משורשרות
typedef struct node{ int data; struct node *next; }node; node* orderList(node* head){ node* temp,*run,*odd=NULL,*even=NULL; while(head){ temp=head; head=head->next; temp->next=NULL; if(temp->data%2){ temp->next=odd; odd=temp; } else{ if(!even) even=temp; for(run=even;run->next;run=run->next); temp->next=run->next; run->next=temp; temp->value=(temp->value*2); return odd; run->next=odd; return even;

20. שאלה ממבחן:
רשימות משורשרות

21. שאלה ממבחן - המשך
ג'.

22. פתרון

23. שאלה ממבחן:

24. (! ||

25. פתרון