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

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

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

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

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

6. לפני שבוע int Count(Item * L) { int counter=0; while (L) counter++;
L=L->next; }
return counter;
int CountR(Item * L)
if (L == NULL)
return 0;
return 1 + CountR(L->next);

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

8. לפני שבוע 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; }

9. מערכים דו מימדים ניתן להכליל את המערך הרגיל של C ( החד מימדי)
למספר רב של מימדים.
אנחנו נראה כיצד להכליל את המערכים שלמדנו
לשני מימדים.
נחשוב על מערכים דו מימדים כל טבלה שלה
עמודות ושורות.

10. מערכים דו מימדים a[0][0] a[0][1] a[0][2] a[0][3] a[1][0] a[1][1]
עמודה 1
עמודה 2
עמודה 3
עמודה 4
a[0][0]
a[0][1]
a[0][2]
a[0][3]
a[1][0]
a[1][1]
a[1][2]
a[1][3]
a[2][0]
a[2][1]
a[2][2]
a[2][3]
שורה 0
שורה 1
שורה 2
שם המערך
אינדקס שורה
אינדקס עמודה

11. מערכים דו מימדים הגדרת מערך דו מימדי תתבצע כך: int main() {
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; }
אתחול שורה 0
אתחול שורה 1
אתחול שורה 2
שם המערך
מספר שורות
מספר עמודות

12. #include <stdio.h> #define ROW 3 #define COLUMN 4 int main() {
int array1[ROW][COLUMN]= {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int i, j;
for ( i = 0; i < ROW; i++ )
for ( j = 0; j < COLUMN; j++ )
printf( "%4d", a[ i ][ j ] );
printf( "\n" ); }
מעבר על השורות
הדפסת כל שורה

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

14. void printArray(int a[][ COLUMN ] , int size ) { int i, j;
for ( i = 0; i < size; i++ )
for ( j = 0; j < COLUMN; j++ )
printf( "%4d", a[ i ][ j ] );
printf( "\n" ); }
מעבר על השורות
הדפסת כל שורה

15. מערכים דו מימדים ופונקציות
אנחנו מתייחסים למערך דו מימדי כאליו זו טבלה אבל
בזיכרון הוא מופיע כמערך רגיל כדי שבתוך הפונקציה נוכל
לפנות לאיברו של המערך באמצעות [][] חייבים לציין את
גודל כל שורה כלומר את מספר העמודות 1 2 3 4 5 6
אשליה
מציאות
1 2 3
5 6 7

16. מערכים דו מימדים ופונקציות
כדי לגשת לתא a[1][1] צריך לדעת שהשורה ה 0
מכילה 3 תאים למעשה מה שמתבצע בפועל זה
a[row][col] a[row*COLUMN+col] a[1][1] a[1*COLUMN+1]
0 1 2 3 4 5 1 2 3 4 5 6
אשליה
מציאות
0 1 2
0 1
1 2 3
4 5 6

17. #include <stdio.h>
#define ROW 3
#define COLUMN 4
void printArray(int [][ COLUMN ] , int );
int main() {
int array1[ ROW ][ COLUMN ] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
printf( "Values in array1 by row are:\n" );
printArray( array1 , ROW );
return 0; }
void printArray(int a[][ COLUMN ] , int size )
int i, j;
for ( i = 0; i < size; i++ ) {
for ( j = 0; j < COLUMN; j++ )
printf( "%4d", a[ i ][ j ] );
printf( "\n" );

18. תרגיל כתוב פונקציה המקבלת מערך דו מימדי בגודל
10X10 וממלאת אותו בלוח הכפל.
התוכנית תדפיס את לוח הכפל המתקבל

19. פתרון void fillArray( int a[][ COLUMN ] , int size ) { int i, j;
for ( i = 0; i < size; i++ ) {
for ( j = 0; j < COLUMN; j++ )
a[ i ][ j ] = (i+1)*(j+1); }

20. מערכים דו מימדים ומחרוזות
נגדיר מערך דו מימדי שיכיל שמות.
לצורך זה כל שורה במערך תהיה מחרוזת:
char names[N][STR_SIZE]; G a d i \0 R m I D n
#define N 3
#define STR_NAME 5
מה הערכים של N וSTR_NAME

21. מערכים דו מימדים ומחרוזות
נכתוב פונקציה שמקבלת שם ומערך. אם השם נמצא
במערך הפונקציה תסמן את השם ב *.
כיצד נגדיר את הפונקציה?
void markName (char [][STR_SIZE],int size,char *name)

22. מערכים דו מימדים ומחרוזות
void markName(char Names[][STR_SIZE],int size,char *name) {
int i;
for ( i = 0; i < size; i++ )
if (strcmp(Names[i],name) == 0)
strcat(Names[i],"*");
return; }

23. תרגיל חזרה – חיפוש במערכים
נתון מערך ממוין נרצה לחפש בו איבר כלשהו.
חיפוש ליניארי
חיפוש בינארי 5 8 9 12 15 17 20 21 24 27 29 31
נחפש את 24 חיפוש ליניארי

24. תרגיל חזרה – חיפוש במערכים5 8 9 12 15 17 20 21 23 24 29 31
נחפש את 24 חיפוש בינארי

25. #include <stdio.h>
#define SIZE 12
int binarySearch( int [], int ,int);
int main() {
int a[ SIZE ] = {12,14,16,18,20,23,24,45,67,89,100,110};
int i;
for (i=0;i<SIZE;i++)
if (binarySearch( a, SIZE , a[i] ))
printf("Found %d \n",i);
return 0; }

26. int binarySearch( int arr[], int size, int item ){
int lsize,rsize,middle;
lsize = 0;
rsize = size-1;
while ( lsize <= rsize )
middle = (rsize + lsize ) /2;
if ( item == arr[ middle ] )
return 1;
if ( item < arr[ middle ] )
rsize = middle-1;
else
lsize = middle+1; }
return 0; 5 8 9 12 15 17 20 21 24 27 29 31

27. הערות לבחינה קראו היטב את השאלות לפני שתתחילו לפתור את המבחן.
שימו לב מה מבקשים תוכנית או רק פונקציה.
השתדלו לכתוב בכתב ברור במקום שמיועד לתשובה.

28. דברים חשובים לולאות (תחביר, שימוש נכון, תנאי סיום) ריקורסיות מערכים
מצביעים (העברה לפונקציה כתובות כדי לשנות ערכי משתנים)
שילוב של מערכים ומצביעים
מחרוזות
מבנים
הקצאת זיכרון דינאמית
רשימות מקושרות

29. דברים חשובים
בהצלחה !