1. שאלה 1

2. הגדרת השאלה
אם נתונות ההגדרות הבאות:
typedef struct listNode{
type data;
struct listNode* next;
}ListNode;
typedef struct list{
ListNode* head;
ListNode* tail;
}List;
הערות:
שימו לב ששדה ה- data ברשומה ListNode הוגדר מטיפוס type. הכוונה היא שהטיפוס type יכול להיות כל טיפוס (int, float, chat*, …). כלומר, לכל טיפוס type מוגדר אוסף הפונקציות לעיל.

3. ניתן להשתמש (מבלי לממש) בפונקציות להלן:
List makeEmptyList();
int isEmpty(List lst);
ListNode* createNode(type data, ListNode* next);
void insertNodeToHead(List* lst, ListNode* newHead);
void insertNodeToTail(List* lst, ListNode* newTail);
List appendLists(List lst1, List lst2);
הערות:
אם אתם נדרשים לפונקציות עזר נוספות, ממשו אותם בעצמכם.

4. מעוניינים לממש רשימה של מערכים של מצביעים למספרים שלמים
מעוניינים לממש רשימה של מערכים של מצביעים למספרים שלמים. המערכים עצמם יכולים לגדול ולקטון.
נתונה הגדרה לאיבר ברשימה מקושרת חד-כיוונית ולרשימה של מערכים של מצביעים למספרים שלמים:
typedef struct ArrayNode {
int **arr;/* המערך */
int size; /* גודלו הנוכחי */
struct ArrayNode *next; /* מצביע לאיבר הבא */
} ArrayNode;
typedef struct ArrayList
ArrayNode *head;
ArrayNode *tail;
} ArrayList;

5. רשימה לדוגמה:

6. כתבו את הפונקציה:
void deleteValueFromList(ArrayList *theList, int toRemove);
הפונקציה מוחקת את כל המופעים של toRemove מכל המערכים שמוצבעים על ידי איברי הרשימה
גודלו של מערך שנמחקו ממנו איברים יתעדכן, ואם הוא הפך להיות מערך ריק (בגודל 0) האיבר יימחק מהרשימה

7. למשל, אם נשלח לפונקציה את הרשימה הבאה:
ואת הערך 77, הרשימה תהיה:

8. הפתרון

9. typedef struct ArrayNode { int. arr;/. המערך. / int size; /
typedef struct ArrayNode { int **arr;/* המערך */ int size; /* גודלו הנוכחי */ struct ArrayNode *next; /* מצביע לאיבר הבא */ } ArrayNode; typedef struct ArrayList ArrayNode *head; ArrayNode *tail; } ArrayList; ArrayList makeEmptyList(); int isEmpty(ArrayList lst); ArrayNode* createNode(int** arr, int size, ArrayNode* next); void insertNodeToHead(ArrayList* lst, ArrayNode* newHead); void insertNodeToTail(ArrayList* lst, ArrayNode* newTail);
המבנים הנתונים והפונקציות של רשימות מקושרות מותאמות לטיפוס שהוגדר בשאלה

10. מימושי הפונקציות של רשימות מקושרות (נתון שאין צורך לממש)
ArrayList makeEmptyList() { ArrayList lst; lst.head = lst.tail = NULL; return lst; } int isEmpty(ArrayList lst) return lst.head == NULL; ArrayNode* createNode(int** arr, int size, ArrayNode* next) ArrayNode* newNode = (ArrayNode*)malloc(sizeof(ArrayNode)); newNode->arr = arr; newNode->size = size; newNode->next = next; return newNode;
מימושי הפונקציות של רשימות מקושרות (נתון שאין צורך לממש)

11. המשך מימושי הפונקציות של רשימות מקושרות (נתון שאין צורך לממש)
void insertNodeToHead(ArrayList* lst, ArrayNode* newHead) {
if (isEmpty(*lst))
lst->head = lst->tail = newHead;
else
newHead->next = lst->head;
lst->head = newHead; }
void insertNodeToTail(ArrayList* lst, ArrayNode* newTail)
lst->head = lst->tail = newTail;
lst->tail->next = newTail;
lst->tail = newTail;
המשך מימושי הפונקציות של רשימות מקושרות (נתון שאין צורך לממש)

12. void putValuesInList(ArrayList* theList); void printArrayList(ArrayList* theList); void printArrayNode(ArrayNode* theNode); void deleteValueFromList(ArrayList *theList, int toRemove); void deleteValueFromArrayNode(ArrayNode* theNode, int value); void main() { int valueToDelete; int fContinue = 1; ArrayList theList = makeEmptyList(); putValuesInList(&theList); printArrayList(&theList); do { … } while (fContinue); // free all memory... }
main לדוגמה
do {
printf("\nEnter value to delete, -1 to exit: ");
scanf("%d", &valueToDelete);
if (valueToDelete == -1)
fContinue = 0;
else {
deleteValueFromList(&theList, valueToDelete);
printf("The updated list:\n");
printArrayList(&theList); }
} while (fContinue);

13. מימוש פונקציות העזר הקשורות להדפסת הרשימה
void printArrayNode(ArrayNode* theNode) { int i; printf("Node has %d values: ", theNode->size); for (i = 0; i < theNode->size; i++) printf("%d ", *theNode->arr[i]); } void printArrayList(ArrayList* theList) ArrayNode* temp = theList->head; while (temp != NULL) printArrayNode(temp); printf("\n"); temp = temp->next;
מימוש פונקציות העזר הקשורות להדפסת הרשימה

14. מימוש פונקציית העזר הקשורה ליצירת הרשימה
void putValuesInList(ArrayList* theList) { srand((unsigned int)time(NULL)); int i, j, numOfArrays = (rand() % 10) + 1; printf("Creating %d arrays\n", numOfArrays); for (i = 0; i < numOfArrays; i++) ArrayNode* newNode = (ArrayNode*)calloc(1, sizeof(ArrayNode)); newNode->size = rand() % 10; newNode->arr = (int**)malloc(sizeof(int*)*newNode->size); for (j = 0; j < newNode->size; j++) newNode->arr[j] = (int*)malloc(sizeof(int)); *newNode->arr[j] = rand() % 10; } insertNodeToTail(theList, newNode);
מימוש פונקציית העזר הקשורה ליצירת הרשימה

15. ולבסוף סוף-סוף, מימוש הפונקציה המבוקשת
void deleteValueFromList(ArrayList *theList, int toRemove) { ArrayNode* temp = theList->head; ArrayNode* prev = theList->head; while (temp != NULL) deleteValueFromArrayNode(temp, toRemove); if (temp->size == 0) ... } else prev = temp; temp = temp->next;
ולבסוף סוף-סוף, מימוש הפונקציה המבוקשת
if (theList->head == theList->tail) {
free(temp);
prev = temp = theList->head = theList->tail = NULL; }
else if (temp == theList->head)
prev = theList->head = temp->next;
temp = theList->head;
else if (temp == theList->tail)
theList->tail = prev;
prev->next = temp = NULL;
else
prev->next = temp->next;
temp = prev->next;

16. מימוש הפונקציה המוחקת מצומת יחיד
void deleteValueFromArrayNode(ArrayNode* theNode, int value) { int i; for (i = 0; i < theNode->size; i++) if (*theNode->arr[i] == value) int j; free(theNode->arr[i]); for (j = i + 1; j < theNode->size; j++) theNode->arr[j - 1] = theNode->arr[j]; } theNode->size--; i--;
מימוש הפונקציה המוחקת מצומת יחיד

17. שאלה 2

18. char ***Neighborhood;
הגדרת השאלה
מעוניינים לאחסן את שמות כל הדיירים בכל הבניינים בשכונה נתונה
לצורך כך מגדירים את המערך:
 char ***Neighborhood;
המשתנה Neighborhood יהיה מערך דינמי אשר יכיל בסופו של דבר את שמות כל הדיירים בשכונה
מספר השורות של המערך יהיה גדול ב-1 ממספר הבניינים בשכונה, כך שאם בשכונה ישנם m בניינים, הוא יכיל m+1 שורות והתא האחרון יהיה NULL
כל בניין יכיל את שמות הדיירים בו, כך שאם בבניין ישנם k דיירים המשתנה Neighborhood יכיל k+1 עמודות והתא האחרון יהיה NULL

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

20. char. createNeighbourhood(); void printNeighberhood(char
char*** createNeighbourhood(); void printNeighberhood(char*** neighberhood); void freeNeighberhood(char*** neighberhood); void main() { char*** neighberhood = createNeighbourhood(); printf("Orig neighberhood:\n"); printNeighberhood(neighberhood); freeNeighberhood(neighberhood); system("pause"); }
main לדוגמה ליצירת שכונה, הדפסתה ושחרור ההקצאות

21. char. createNeighbourhood() { char
char*** createNeighbourhood() { char*** neighberhood; int numOfBuildings, i, j; printf("How many buildings in the neighbourhood? "); scanf("%d", &numOfBuildings); neighberhood = (char***)calloc(numOfBuildings+1, sizeof(char**)); for (i = 0; i < numOfBuildings; i++) int numOfNeighboursInBuilding; printf("How many neighbours are there in building #%d? ", i+1); scanf("%d", &numOfNeighboursInBuilding); getchar(); // to clean the enter from the buffer neighberhood[i] = (char**)calloc(numOfNeighboursInBuilding + 1, sizeof(char*)); … } return neighberhood;

22. neighberhood[i] = (char
neighberhood[i] = (char**)calloc(numOfNeighboursInBuilding + 1, sizeof(char*)); for (j = 0; j < numOfNeighboursInBuilding; j++) { int numOfLettesInName = 0; char temp; printf("Enter name #%d: ", j + 1); do scanf("%c", &temp); if (temp != '\n') neighberhood[i][j] = (char*)realloc(neighberhood[i][j], (numOfLettesInName + 1)*sizeof(char)); neighberhood[i][j][numOfLettesInName] = temp; } numOfLettesInName++; } while (temp != '\n'); neighberhood[i][j] = (char*)realloc(neighberhood[i][j], (numOfLettesInName) * sizeof(char)); neighberhood[i][j][numOfLettesInName-1] = '\0';

23. void freeNeighberhood(char
void freeNeighberhood(char*** neighberhood) { int i, j; for (i = 0; neighberhood[i] != NULL; i++) for (j = 0; neighberhood[i][j] != NULL; j++) free(neighberhood[i][j]); } free(neighberhood[i]); free(neighberhood);
void printNeighberhood(char*** neighberhood) {
int i, j;
for (i = 0; neighberhood[i] != NULL; i++)
printf("Building #%d: ", i+1);
for (j = 0; neighberhood[i][j] != NULL; j++)
printf("%s, ", neighberhood[i][j]); }
printf("\b\b \n");

24. סעיף ב
נתונות ההגדרות הבאות: typedef struct listNode { char *data; struct listNode* next; }ListNode; typedef struct list { ListNode* head; ListNode* tail; }List; כתבו את הפונקציה: char *** collectAndRemoveNames(char ***neighborhood, List *APeople) שמקבלת שכונה ומחזירה במשתנה APeople רשימה מקושרת של שמות הדיירים המתחילים באות 'A'. מדובר בכל השמות מכל הבניינים בשכונה כמו-כן, הפונקציה תמחק את הדיירים הללו מהמערך neighborhood. במידה ובבניין מסוים נמחקו כל הדיירים, יש למחוק את הבניין ולהקטין את המערך neighborhood. ניתן להניח שלא ימחקו כל הבניינים. הפונקציה תחזיר את המערך neighborhood המעודכן.

25. void main() {
List res;
char*** neighberhood = createNeighbourhood();
printf("Orig neighberhood:\n");
printNeighberhood(neighberhood);
neighberhood = collectAndRemoveNames(neighberhood, &res);
printf("Neighberhood without A-names:\n");
printf("All names starting with A:\n");
printList(&res);
freeNeighberhood(neighberhood);
system("pause"); }
char*** createNeighbourhood(); void freeNeighberhood(char*** neighberhood); void printNeighberhood(char*** neighberhood); typedef struct listNode { char *data; struct listNode* next; }ListNode; typedef struct list { ListNode* head; ListNode* tail; }List; List makeEmptyList(); int isEmpty(List lst); ListNode* createNode(char* data, ListNode* next); void insertNodeToHead(List* lst, ListNode* newHead); void insertNodeToTail(List* lst, ListNode* newTail); void printList(List* theList); char*** collectAndRemoveNames(char*** neighborhood, List *APeople);

26. List makeEmptyList() { List lst; lst. head = lst
List makeEmptyList() { List lst; lst.head = lst.tail = NULL; return lst; } int isEmpty(List lst) return lst.head == NULL; ListNode* createNode(char* data, ListNode* next) ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); newNode->data = data; newNode->next = next; return newNode;

27. void insertNodeToHead(List. lst, ListNode. newHead) { if (isEmpty(
void insertNodeToHead(List* lst, ListNode* newHead) { if (isEmpty(*lst)) lst->head = lst->tail = newHead; else newHead->next = lst->head; lst->head = newHead; } void insertNodeToTail(List* lst, ListNode* newTail) lst->head = lst->tail = newTail; lst->tail->next = newTail; lst->tail = newTail;

28. void printList(List. theList) { ListNode
void printList(List* theList) { ListNode* temp = theList->head; while (temp != NULL) printf("%s, ", temp->data); temp = temp->next; } printf("\b\b \n");

29. char. collectAndRemoveNames(char. neighborhood, List
char*** collectAndRemoveNames(char*** neighborhood, List *APeople) { int i, j, k; *APeople = makeEmptyList(); for (i=0 ; neighborhood[i] != NULL ; i++) for (j=0 ; neighborhood[i][j] != NULL ; j++) if (neighborhood[i][j][0] == 'a' || neighborhood[i][j][0] == 'A') insertNodeToTail(APeople, createNode(neighborhood[i][j], NULL)); // remove current name from building for (k = j + 1 ; neighborhood[i][k] != NULL ; k++) neighborhood[i][k - 1] = neighborhood[i][k]; } neighborhood[i][k-1] = NULL; j--; … return neighborhood;

30. char. collectAndRemoveNames(char. neighborhood, List
char*** collectAndRemoveNames(char*** neighborhood, List *APeople) { int i, j, k; *APeople = makeEmptyList(); for (i=0 ; neighborhood[i] != NULL ; i++) for (j=0 ; neighborhood[i][j] != NULL ; j++) … } // if no names are left in the building, remove current building if (neighborhood[i][0] == NULL) free(neighborhood[i]); for (k = i + 1 ; neighborhood[i][k] != NULL ; k++) neighborhood[k - 1] = neighborhood[k]; neighborhood[k - 1] = NULL; i--; // i also holds the number of buildings neighborhood = (char***)realloc(neighborhood, sizeof(char**)*(i+1)); return neighborhood;