פרק 7 - מערכים

‫קורס יסודות התכנות בשפת ‪C‬‬
‫פרק ‪7‬‬
‫מבני נתונים – מערכים ‪Arrays‬‬
‫ד"ר שייקה בילו‬

‫יועץ ומרצה בכיר למדעי המחשב וטכנולוגית מידע‬
‫מומחה למערכות מידע חינוכיות‪ ,‬אקדמיות ומנהליות‬
‫‪SCE-Chapter-7-Arrays‬‬ ‫‪1‬‬ ‫‪Shayke Bilu PhD‬‬

‫תזכורת‪ :‬פונקציות‬
‫‪2‬‬
‫‪ ‬מהי פונקציה?‬
‫‪ ‬קטע תוכנית שיש לו טיפוס‪ ,‬שם‪ ,‬משתנים‪ ,‬היכול לקבל נתונים‪,‬‬
‫לבצע פעולות חישוב והשוואה ולהחזיר תוצאה‪.‬‬
‫‪ ‬הגדרת פונקציות‪:‬‬
‫טיפוס ושם הפונקציה‪ ,‬סוג הערך המוחזר‪ ,‬הערכים שמועברים‪.‬‬
‫)‪double square(double num‬‬
‫{‬
‫;‪return num*num‬‬
‫}‬
‫‪ ‬קריאה לפונקציה עם הערך המוחזר ממנה‪:‬‬
‫;)‪sum=square(mis‬‬
‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫פונקציות – העברת ערכים‬
3
#include <stdio.h>
int square (int num) ‫אל פונקציה מועברים ערכים‬
{ ‫(השמה) ולא משתנים‬
num*=num;
return num;
}
‫ בתוך‬num ‫שינוי ערך המשתנה‬
‫הפונקציה לא משפיע על ערכו של‬
int main() ‫המשתנה המקורי שנשלח לפונקציה‬
{
int num=16;
printf(“%d is the square of %d”,square(num),num);
return 0;
}
256 is the square of 16 :‫הפלט‬
SCE-Chapter-7-Arrays Shayke Bilu PhD
‫פונקציית סיכום ערכי ספרות המספר‬
‫‪4‬‬
‫>‪#include <stdio.h‬‬ ‫אל פונקציה מועבר הערך של המשתנה‬

‫(השמה) ולא המשתנה עצמו‬
‫)‪int sum(int mis‬‬
‫}‬ ‫שינוי ערך המשתנה ‪ sum‬בתוך‬
‫;‪int sum=0‬‬ ‫הפונקציה לא משפיע על ערכו של‬
‫)‪while(mis>0‬‬ ‫המשתנה המקורי שנשלח לפונקציה‬
‫}‬
‫;‪sum+=mis%10‬‬ ‫לתוך המשתנה המקומי ‪ sum‬מכניסים את‬
‫;‪mis=mis/10‬‬ ‫הספרה הימנית ביותר של המספר ‪mis‬‬
‫}‬ ‫אח"כ מצמצמים את ערכו של‬
‫;‪return sum‬‬ ‫המשתנה ‪ mis‬פי ‪ 10‬ע"י חלוקתו ב‪10-‬‬
‫{‬
‫הערך המוחזר ע"י החזרת ‪ sum‬הוא סכום כל ספרות המספר ‪mis‬‬
‫פונקציית סיכום כמות ספרות במספר‬
‫‪5‬‬
‫)‪int count(int mis‬‬

‫}‬ ‫אל פונקציה מועבר ערך‬
‫;‪int cnt=0‬‬ ‫(השמה) ולא משתנים‪.‬‬
‫)‪while(mis>0‬‬
‫שינוי ערך המשתנה בפונקציה לא משפיע‬
‫}‬ ‫על המשתנה המקורי‪.‬‬
‫;‪mis/=10‬‬
‫;‪cnt++‬‬ ‫לתוך המשתנה המקומי ‪ cnt‬מכניסים את מספר‬
‫הספרה לאחר קיצוץ של המספר ‪ mis‬פי ‪10‬‬
‫}‬
‫;‪return cnt‬‬
‫{‬
‫הערך המוחזר ע"י החזרת ‪ cnt‬הוא כמות הספרות של המספר ‪mis‬‬
‫הכרזה על פונקציות‬
‫‪6‬‬
‫‪ ‬כדי להשתמש בפונקציה‪ ,‬צריך שהיא תהיה מוגדרת‪.‬‬

‫‪ ‬לכן רשמנו תמיד את הפונקציה לפני ה‪ ,main -‬שם‬
‫קראנו לה וכך התוכנית הראשית הכירה אותה‪.‬‬
‫‪ ‬אופציה נוספת מאפשרת כתיבת הפונקציה אחרי‬
‫התוכנית הראשית‪:‬‬
‫יש לרשום הכרזה (‪ )declaration‬של הפונקציה בתחילת‬ ‫‪.1‬‬
‫הקובץ מיד מתחת להגדרת הספריות‪.‬‬
‫יש לרשום את המימוש שלה )‪ (definition‬בסופו של‬ ‫‪.2‬‬
‫הקובץ או בקובץ נפרד אך באותו פרויקט‪.‬‬
?‫הכרזה – איך זה נראה‬
7
:(declaration, prototype( ‫ דוגמא להכרזה‬

double power(double base, int exponent);
:‫ ומותר גם בלי שמות המשתנים‬
double power(double, int);
:)definition( ‫ רק בסוף הקובץ נרשום את ההגדרה המלאה‬
double power(double base, int exponent)
{
int i;
double result=1;
for(i=1; i<=exponent; i++)
result=result*base;
return result;
}
‫פונקציות – הצהרה לפני תוכנית ראשית‬
‫‪8‬‬
‫>‪#include <stdio.h‬‬
‫הפונקציה מוכרזת מיד‬
‫;)(‪void get_digit‬‬
‫לאחר הגדרת הספריות‬
‫)(‪int main‬‬
‫}‬ ‫התוכנית הראשית קוראת לפונקציה לביצוע‪:‬‬
‫;)(‪get_digit‬‬
‫;‪return 0‬‬
‫{‬

‫פונקציות – הפעלה אחרי התוכנית הראשית‬
9
:‫הפונקציה כוללת את כל הפעילות הנדרשת כמו בתוכנית‬

void get_digit() ,‫ הגדרת משתנים וטיפוסיהם‬,‫הגדרת טיפוס הפונקציה‬
} ‫ הצבות והחזרת תוצאה‬,‫ חישובים‬,‫ביצוע קלט ופלט‬
int counter, digit, mis, i;
printf("Enter int number and other number\n");
scanf("%d %d",&mis, &i);
for (counter = 1; counter < i; counter++)
mis /= 10;
digit = mis % 10;
printf("in place %d the digit is %d.\n",i,digit);
{
10
?‫שאלות על השעור הקודם‬

‫שאלה‬
‫‪11‬‬
‫‪ ‬יש צורך לבנות מערכת בדיקה המבצעת את המשימות הבאות‪:‬‬

‫‪ .1‬קליטת ‪ 10‬ערכים ל‪ 10 -‬משתנים‪ ,‬כולם בעלי אותו טיפוס‪.‬‬
‫‪ .2‬הדפסת כל ‪ 10‬הערכים שנקלטו באופי סודר על המסך לאחר‬
‫קליטתם‪.‬‬
‫‪ .3‬ביצוע מספר חישובים על קבוצת הערכים כמו מציאת מקסימום‪,‬‬
‫מינימום‪ ,‬ממוצע‪ ,‬מיון הקבוצה מגדול לקטן ולהיפך וכדומה‪.‬‬
‫‪ .4‬הדפסת התוצאות שנמצאו עבור מינימום‪ ,‬מקסימום‪ ,‬ממוצע כולל‬
‫המיונים על המסך תוך שמירת הערכים עד סוף ריצת התוכנית‪.‬‬

‫מה היינו רוצים שיתרחש בפועל?‬
‫‪12‬‬
‫‪ ‬נרצה לבצע מספר רב של פעולות זהות על מספר רב של משתנים‬

‫מאותו סוג‪ ,‬אבל‪ ,‬היינו רוצים לכתוב אותן פעם אחת בלבד‪:‬‬
‫‪ ‬להגדיר בבת‪-‬אחת ‪ 10‬משתנים מאותו סוג או יותר‪.‬‬
‫‪ ‬לכתוב פעם אחת את פקודת הקלט‪ ,‬ושהמחשב יבצע אותה ‪10‬‬
‫פעמים או יותר‪ ,‬כל פעם למשתנה המתאים‪.‬‬
‫‪ ‬לכתוב פעם אחת את הדפסת הפלט‪ ,‬ושזה יבוצע עבור כל אחד‬
‫מ‪ 10-‬המשתנים בסדר המתאים‪.‬‬
‫‪ ‬לאפשר חיפוש ומציאת מינימום‪ ,‬מקסימום חישוב ממוצע‪,‬‬
‫סידור ומיון של הערכים תוך כדי אפשרות שמירת הסדר‬
‫המקורי בו נקלטו‪.‬‬

‫הפתרון ‪ -‬מערכים‬
‫‪13‬‬
‫הגדרה‪:‬‬ ‫•‬
‫אוסף סדור של משתנים מאותו סוג בכתובות רציפות בזיכרון‪.‬‬ ‫•‬
‫לכל המשתנים יש שם משותף ואינדקס (מספר סידורי)‪.‬‬ ‫•‬
‫בעזרת השם והאינדקס ניתן לגשת למשתנה מסוים באוסף‪.‬‬ ‫•‬
‫‪9‬‬ ‫‪.‬‬ ‫‪. . . 5 . . . 7‬‬

‫]‪arr[0‬‬ ‫]‪arr[9‬‬ ‫יתרונות‪:‬‬ ‫•‬
‫ניתן לבצע את אותה פעולה על משתנים שונים במערך ע"י‬ ‫•‬
‫שינוי אינדקס הגישה‪:‬‬

‫• בעזרת לולאה ‪...‬‬
‫• בעזרת תנאי‪...‬‬
‫פתרון באמצעות מערכים‬
14
#include <stdio.h>
#define SIZE 10 ‫ מספרים ומדפיסה אותם בסדר הפוך‬10 ‫התוכנית קולטת‬
void main()
{
int i; float ‫ משתנים מסוג‬10 ‫מגדירים מערך של‬
float input[SIZE];
printf(“Enter the 10 floats:\n”); ‫עוברים בלולאה על המשתנים‬
for (i=0; i<SIZE; i++)
9 ‫ עד תא‬0 ‫ מתא‬,‫קלט לתאי המערך‬
scanf(“%f”, &input[i]);
for (i=SIZE-1; i>=0; i--)
printf(“%.2f\n”, input[i]); 0 ‫ עד תא‬9 ‫ מתא‬,‫הדפסה בסדר הפוך‬
}
15
?‫שאלות‬

‫נושאי הפרק מערכים‪:‬‬
‫‪16‬‬
‫הגדרת המושג מערך והצורך בו‬ ‫‪‬‬

‫שימושים נפוצים במערכים‬ ‫‪‬‬
‫הגדרת סוגי מערכים שונים‬ ‫‪‬‬
‫שיטות לאתחול מערכים‬ ‫‪‬‬
‫גישה לתאי מערך באופן סודר‬ ‫‪‬‬
‫גישה לתאי מערך באופן ישיר‬ ‫‪‬‬
‫העברת מערך (כתובתו) לפונקציה‬ ‫‪‬‬
‫עדכון נתוני המערך בפונקציה‪ ,‬סידור‪ ,‬מיון ארגון מחדש‬ ‫‪‬‬
‫מערכים רב‪-‬ממדיים (דו ממדי‪/‬תלת ממדי)‬ ‫‪‬‬
‫הגדרת המושג מערך‬
‫‪17‬‬
‫‪ ‬מערך‪:‬‬
‫‪ o‬משתנה המגדיר "קבוצה" של משתנים מאותו טיפוס‬
‫(‪ int, char, float, double‬או כל טיפוס אחר)‬
‫‪ o‬הגדרת המערך מקצה רצף של משתנים בזיכרון‪.‬‬
‫‪9 .‬‬ ‫‪. . 8 . . 4 . 5‬‬
‫]‪arr[0‬‬ ‫]‪arr[9‬‬
‫בעת הגדרת המערך יש לציין את טיפוס המשתנים ואת מספר‬ ‫‪o‬‬
‫איבריו ע"י מספר קבוע‪.‬‬
‫למשל כך נגדיר מערך של ‪)SIZE( 10‬משתנים מטיפוס ‪:int‬‬ ‫‪o‬‬
‫;]‪int arr[SIZE‬‬
‫גישה סודרת לתאי המערך‬
18
#include <stdio.h>
#define SIZE 10 ‫ מספרים ומדפיסה אותם בצורות שונות‬10 ‫התוכנית קולטת‬
int main()
{
int i,numbers[SIZE]; int ‫ משתנים מטיפוס‬10 ‫מגדירים מערך של‬
printf(“Enter the 10 integers:\n”);
scanf(“%d”, &numbers[i]); 9 ‫ עד תא‬0 ‫ מתא‬,‫קלט לתאי המערך‬
for (i=0; i<SIZE; i+=2)
printf(“%6d”, numbers[i]); ‫הדפסת האיברים בתאים הזוגיים‬
for (i=1; i<SIZE; i+=2)
printf(“%6d”, numbers[i]); ‫הדפסת האיברים בתאים האי הזוגיים‬
}
‫גישה ישירה לתאים במערך‬
‫‪19‬‬
‫‪ ‬ניתן לגשת לתא במערך ע"י כתיבת שם המערך ומספרו‬

‫הסידורי בסוגריים מרובעים בצמוד אליו‪.‬‬
‫‪ ‬מספור התאים מתחיל תמיד מ‪.0 -‬‬
‫‪ ‬תא מסוים במערך שקול למשתנה רגיל מאותו הסוג‪.‬‬
‫‪ ‬מספר התא האחרון במערך הוא תמיד כמות התאים פחות ‪.1‬‬
‫;‪arr[0]=5‬‬
‫‪5 .‬‬ ‫‪. . 8 . 3 . . 4‬‬
‫;‪arr[4]=8‬‬
‫;‪arr[6]=3‬‬ ‫]‪arr[0‬‬ ‫]‪arr[4‬‬
‫]‪arr[6‬‬
‫;‪arr[9]=4‬‬ ‫]‪arr[9‬‬
‫שיטות לאתחול מערכים בשורת ההגדרה‬
‫‪20‬‬
‫‪ ‬הערכים מוצבים בתאים לפי הסדר החל מהתא הראשון‪.‬‬

‫‪ ‬אם אין מספיק ערכים מוגדרים מראש‪ ,‬שאר התאים‬
‫מאותחלים אוטומטית לערך ‪.0‬‬
‫;}‪int arr[5]={8, 5‬‬
‫‪8 5 0 0 0‬‬
‫]‪arr[0‬‬ ‫]‪arr[4‬‬
‫;}‪int arr[10]={0‬‬
‫‪0 0 0 0 0 0 0 0 0 0‬‬
‫]‪arr[0‬‬ ‫]‪arr[9‬‬
‫שיטות לאתחול מערכים בשורת ההגדרה‬
‫‪21‬‬
‫‪ ‬ניתן להגדיר מערכים בצורה זו אך ורק בשורת ההגדרה‪:‬‬

‫;}‪double input[3]={2.56, 5.89, 7.589‬‬
‫;}‪float mis[4]={25.6, 89.56, 9.785, 12.256‬‬
‫;}‪int arr[5]={0,1,2,3,4‬‬
‫‪ ‬אם לא נציין את מספר תאי המערך‪ ,‬הוא יהיה כמספר ערכי‬
‫האתחול (בדוגמא הבאה יהיו לו ‪ 6‬תאים)‪:‬‬
‫;}‪int arr[ ]={14, 52, 33, 94, 75, 46‬‬

‫מערכים אחרי שורת ההגדרה‬
‫‪22‬‬
‫‪ ‬אחרי הגדרת המערך אפשר להתייחס לכל תא בנפרד‪.‬‬

‫‪ ‬אי‪-‬אפשר לשים ערכים בתאי המערך בבת‪-‬אחת‪:‬‬
‫‪ ‬למשל אי‪-‬אפשר לאפס בבת‪-‬אחת את כל התאים ע"י ‪arr=0‬‬
‫‪ ‬צריך לעשות זאת ע"י לולאה‪:‬‬
‫)‪for(i=0; i< SIZE; i++‬‬
‫;‪arr[i]=0‬‬
‫‪ ‬אי‪-‬אפשר להעתיק מערך למערך אחר ע"י פעולת ‪arr = bll‬‬
‫‪ ‬זה דורש לולאה‪:‬‬
‫)‪for(i=0; i< SIZE; i++‬‬
‫;]‪arr[i]=bll[i‬‬
‫‪ ‬כך גם לגבי פעולות השוואה‪ ,‬הדפסה‪ ,‬קלט‪ ,‬וכו'‬
‫חריגה מגבולות המערך‬
‫‪23‬‬
‫‪ ‬מותר לגשת לכל תא במערך לפי כתובתו‪ ,‬בתנאי שהכתובת שייכת‬

‫לתחום המוגדר של המערך‪.‬‬
‫‪ ‬אסור לגשת לתאים שנמצאים מחוץ למערך כי אז יש גלישה‪.‬‬
‫;]‪int arr[SIZE‬‬ ‫‪ ‬גישה לתא שנמצא מחוץ למערך תגרום לבעיות‪:‬‬
‫;‪int i = 0‬‬ ‫‪ ‬בסבירות גבוהה התוכנית תקרוס‪.‬‬
‫) ‪for ( i=0; i <= SIZE; ++i‬‬ ‫‪ ‬או שהיא פשוט לא תעבוד כראוי‪.‬‬
‫{‬
‫;‪arr[i] = i‬‬ ‫‪ ‬למשל‪:‬‬
‫}‬
‫התא‪ arr[10] :‬לא שייך למערך !!!‬

‫נקודה לתשומת‪-‬לב‬
‫‪24‬‬
‫‪ ‬בהגדרת מערך הגודל שלו חייב להיות מספר קבוע‪ ,‬ולא‬

‫יכול להיות ערך של משתנה לוקאלי‪.‬‬
‫‪ ‬למשל‪:‬‬
‫;‪int my_size=10‬‬ ‫ולא‪:‬‬

‫;]‪int arr[my_size‬‬ ‫ולא‪:‬‬
‫;]‪int arr[2.5‬‬ ‫ולא‪:‬‬

‫עוד נקודה לתשומת‪-‬לב‬
‫‪25‬‬
‫‪ ‬גודל מערך יכול להיות קבוע שמוגדר ב‪#define -‬‬

‫‪ ‬קבוע כזה הוא מספר המוגדר גלובלית שאינו יכול‬
‫להשתנות במהלך ריצת התוכנית‪.‬‬
‫‪#define SIZE 10‬‬
‫‪ ‬במקרה זה הקבוע ‪ SIZE‬שערכו נקבע ל‪ 10 -‬משמש‬
‫כגודל המערך ‪arr‬‬

‫מערכים ‪ -‬סיכום‪-‬ביניים‬
‫‪26‬‬
‫● משמעות הגדרת מערך – הטיפוס‪ ,‬הגודל‪ ,‬השימוש‬

‫● הגדרה ואתחול מערכים – איפוס‪ ,‬ישיר‪ ,‬בקליטה‪,‬‬
‫חלקי‪...‬‬
‫● גישה לתאים ישיר וסודר – דרך אינדקס‪ ,‬ע"י לולאה‪...‬‬
‫● חריגה מגבולות המערך – גלישה מהכתובת האחרונה‬
‫● משתנה גלובלי להגדרת מספר תאים במערך – קבוע‬
‫לכל מהלך התוכנית‬
27
?‫שאלות‬

‫ דוגמא נוספת‬- ‫מערכים‬
28
#include <stdio.h>
#define SIZE 10 ‫התוכנית קולטת מספר שלם חיובי ומדפיסה‬
int main() ‫כמה פעמים הופיעה בו כל סיפרה‬
{
int i, num, digits[SIZE]={0};
printf(“Enter a positive integer:\n”);
scanf(“%d”, &num);
while (num!=0) //while(num) ‫ במערך‬i ‫בכתובת של‬
{
digits[num%10]++; ‫יוצבו מספר ההופעות של‬
num=num/10; num ‫ במספר‬i ‫הספרה‬
}
printf(“Digit %d appeared %d times\n”,i,digits[i]);
}
‫ דוגמא נוספת‬- ‫מערכים‬
29
#include <stdio.h>
#define SIZE 10 ‫התוכנית קולטת תווים לתוך מערך‬
void main()
{ .‫ומדפיסה את תוכן המערך התווי‬
int i;
char tavim[SIZE]={'0'};
for(i=0; i<SIZE; i++)
{
printf("Enter a character to place %d:\n”,i+1);
flushall(); //clean buffer
scanf("%c",&tavim[i]);
}
printf(“In place %d is char %c\n",i+1, tavim[i]);
}
‫תרגילי כיתה‬
‫‪30‬‬
‫‪ .1‬כתוב תוכנית המגדירה מערך בעל ‪ 10‬איברים‪ ,‬קולטת לתוכו‬

‫עשרה מספרים ממשיים ומייצרת שני מערכים נוספים‪ .‬הראשון‬
‫יכלול את השורשים של כל אברי המערך הראשון‪ ,‬והשני יכלול‬
‫את החזקות השניות (ריבוע) של אברי המערך המקורי‪ .‬בסיום‬
‫התוכנית תדפיס את ערכי שלושת המערכים במקביל‪.‬‬
‫‪ .2‬כתוב תוכנית המגדירה שני מערכים בגודל ‪ 10‬וקולטת לתוכם‬

‫מספרים שלמים‪ .‬התוכנית תייצר מערך שלישי שיכיל את סכום‬
‫כל שני אברים מקבילים בשני המערכים המקוריים שנקלט‪.‬‬
‫בסיום תדפיס התוכנית את שלושת המערכים במקביל‪.‬‬

1 ‫פתרון תרגול כיתה מספר‬
31
#include <stdio.h>
#include <math.h>
#define SIZE 10
void main()
}
int i;
float input[SIZE],shoresh[SIZE],hezka[SIZE];
printf("Enter the 10 floats:\n");
for(i=0; i< SIZE; i++)
{
printf("Enter number to place %d:\n",i+1);
scanf("%f", &input[i]);
}
1 ‫פתרון תרגול כיתה מספר‬
32
{
printf(“sqrt in place %d=%.2f\n",i+1,
sqrt(input[i]));
shoresh[i] = sqrt(input[i]);
printf("power in place %d=%.2f\n\n“,i+1,
pow(input[i],2));
hezka[i] = pow(input[i],2);
}
printf("number=%.2f,sqrt=%.2f,power=%.2f\n“
,input[i],shoresh[i],hezka[i]);
{
‫‪33‬‬

‫עשרה מספרים שלמים ומייצרת שני מערכים נוספים‪ .‬הראשון‬
‫יכלול את הערכים הנמצאים בכתובות הזוגיות של המערך‬
‫המקורי‪ ,‬והשני יכלול את הערכים הנמצאים בכתובות האי‬
‫זוגיות של המערך המקורי‪ .‬בסיום התוכנית תדפיס את ערכי‬
‫שלושת המערכים במקביל‪.‬‬
‫מספרים שלמים‪ .‬התוכנית תייצר מערך שלישי שיכיל את‬
‫המספר הגדול מבין שני מספרים מקבילים של שני המערכים‬
‫המקוריים‪ .‬בסיום תדפיס התוכנית את שלושת המערכים‬
‫במקביל‪.‬‬
‫‪34‬‬

‫תווים‪ .‬התוכנית תייצר מערך שלישי שיכיל את התו הגדול מבין‬
‫שני התווים המקבילים של שני המערכים המקוריים‪ .‬בסיום‬
‫תדפיס התוכנית את שלושת המערכים במקביל‪.‬‬
‫עשרה תווים ומייצרת שני מערכים נוספים‪ .‬הראשון יכלול את‬
‫התווים שהם אותיות גדולות‪ ,‬והשני יכלול את התווים שהם‬
‫אותיות קטנות‪ .‬בסיום התוכנית תדפיס את ערכי שלושת‬
‫המערכים במקביל‪.‬‬

35
?‫שאלות‬

‫העברת מערך לפונקציה‬
‫‪36‬‬
‫‪ ‬אפשר להעביר לפונקציה מערכים מכל הסוגים‬

‫‪ ‬כתובת המערך מועברת לפונקציה‬
‫‪‬כלומר מועבר המיקום של המערך המקורי בזיכרון‬
‫‪‬שם המערך המועבר משמש כמצביע למיקומו בזיכרון‬
‫‪ ‬גודל המערך לא מועבר לפונקציה‬
‫‪‬באחריותנו לדאוג שהפונקציה לא תחרוג מגודל המערך על‬
‫ידי הגבלת התנועה על המערך באמצעות תחום האינדקס‬
‫‪‬בד"כ נרצה להעביר את גודלו כפרמטר נוסף לתוך משתנה‬
‫לוקאלי או לחילופין נשתמש בגודל המערך כמשתנה גלובלי‬
‫העברת מערך לפונקציה‬
‫‪37‬‬
‫‪ ‬בשונה ממשתנים אחרים העברת המערך ייחודית‪:‬‬

‫‪ ‬כשמעבירים מערך לפונקציה הוא אינו מועתק אלא מצוינת‬
‫כתובת התחלתו בזיכרון‬
‫‪ ‬לפונקציה מועבר המערך המקורי כולל הערכים שבו‬
‫‪ ‬שינוי של ערכי המערך בתוך הפונקציה ישנו את המערך‬
‫המקורי !!!‬
‫‪ ‬מומלץ לתת שם למשתנה המערך בפונקציה המזכיר את‬
‫משתנה המערך בתוכנית הראשית‬

‫העברת מערך לפונקציה ‪ -‬דוגמא‬
‫‪38‬‬
‫‪ ‬נדגים פונקציה שמקבלת מערך של מספרים שלמים ואת גודלו‪,‬‬
‫ומחזירה את סכום המספרים במערך‪.‬‬
‫‪ ‬הקריאה לפונקציה‪:‬‬
‫;)‪sum = calc_sum(array‬‬
‫‪ ‬כותרת הפונקציה‪:‬‬
‫;)] [‪int calc_sum(int array‬‬
‫‪ ‬אין צורך לציין את גודל המערך בתוך ה‪ ] [ -‬בכותרת הפונקציה‬

‫‪ ‬סימון ה‪ ,] [ -‬סוגרים מרובעים‪ ,‬מציין כי המשתנה מערך לוקאלי‬

‫דוגמא פונקציה סיכום איברי מערך‬
39
#include <stdio.h>
#define SIZE 10
int calc_sum(int arr[ ]) ‫פונקציית הסכום‬
{
int i, sum = 0; ‫ מסכמים‬,‫עוברים על תאי המערך בלולאה‬
sum=sum+arr[i]; ‫אותם לתוך משתנה סוכם כאשר בסיום‬
return sum; ‫ומחזירים את הסכום‬
}
int main()
{
int input[SIZE], i;
printf(“Enter 10 integers:\n”); ‫קליטת איברי המערך‬
scanf("%d", &input[i]);
printf("The sum is %d\n", calc_sum(input));
return 0;
} ‫קריאה לפונקציה‬
‫ פונקציית אתחול מערך‬:‫דוגמא נוספת‬
40
#include <stdio.h>
#define SIZE 10 ‫פונקציית האתחול‬
void init_array(int arr[], int size, int value)
{
int i;
for(i=0; i<size; i++)
arr[i]=value;
}
void main()
{ ‫ התאים‬5 ‫הקריאה לפונקציה תאתחל את‬
int arr[SIZE], i; .4 ‫ לערך‬arr ‫הראשונים במערך‬
init_array(arr,5,4);
for(i=0; i<10; i++) !!! ‫המערך המקורי ישתנה‬
printf("%3d\n", arr[i]);
}
‫ פונקציית מקסימום במערך‬:‫דוגמא נוספת‬
41
#include <stdio.h>
#define SIZE 10
void maxarr(int arr[ ])
}
int max=arr[0],i;
for(i=1; i<SIZE ; ++i)
if(arr[i]>max)
max=arr[i];
printf(“Array maximum value : %d\n", max);
{
‫ פונקציית מינימום במערך‬:‫דוגמא נוספת‬
42
void minarr(int arr[ ])

}
int min=arr[0],i;
for(i=1; i<SIZE ; ++i)
if(arr[i]<min)
min=arr[i];
printf(“Array minimum value : %d\n", min);
{
‫ פונקציית סכום איברים‬:‫דוגמא נוספת‬
43
void sumarr(int arr[ ])

}
int sum=0,i;
for(i=0 ; i<SIZE ; ++i)
sum+=arr[i];
printf(“Array sum is : %d\n", sum);
{

‫ התוכנית הראשית‬:‫דוגמא נוספת‬
44
int main()
}
int arr[SIZE] , i ;
for(i=0 ; i<SIZE ; i++)
scanf("%d", &arr[i]); arr ‫קליטת נתונים למערך‬
sumarr(arr); ‫קריאה לפונקציה הראשונה‬
maxarr(arr); ‫קריאה לפונקציה השנייה‬
minarr(arr); ‫קריאה לפונקציה השלישית‬
return 0;
{
45
?‫שאלות‬

‫תרגיל ‪ - 2‬חיפוש במערכים (לינארי)‬
‫‪46‬‬
‫נתון מערך ממוין נרצה לחפש בו איבר כלשהו‪.‬‬

‫‪ ‬חיפוש ליניארי‬
‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 24 27 29 31‬‬
‫נחפש את ‪ 17‬חיפוש רגיל‪ ,‬לינארי‪ ,‬על כל‬

‫איברי המערך מהאיבר הראשון לאחרון‬

‫פתרון חיפוש לינארי במערכים‬
47
#include <stdio.h>
#define SIZE 12
int linarySearch(int arr[], int item )
{
int i;
{
if (arr[i] == item)
{
printf(“The item %d in place %d”,arr[i], i+1);
return 1;
}
}
return 0;
}
‫התוכנית הראשית‬
48
int main()
{
int arr[SIZE]={5,8,9,12,12,17,20,21,24,27,29,31};
int item=17,status=0;
status=linarySearch( arr,item);
if(status == 1)
printf(“Item is found in array!!!\n");
else
printf(“Item is not found in array!!!\n");
return 0;
}
‫תרגיל ‪ - 3‬חיפוש במערכים (בינארי)‬
‫‪49‬‬
‫נתון מערך ממוין נרצה לחפש בו איבר כלשהו‪.‬‬

‫‪ ‬חיפוש בינארי‬
‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 24 27 29 31‬‬
‫נחפש את ‪ 24‬חיפוש בינארי‬

‫תרגיל ‪ - 3‬חיפוש במערכים‬
‫‪50‬‬
‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 23 24 29 31‬‬
‫נחפש את ‪ 24‬חיפוש בינארי‬

‫פתרון חיפוש בינארי במערכים‬
51
#include <stdio.h>
#define SIZE 12
int binarySearch(int arr[ ], int item )
{
int lsize=0, rsize=SIZE-1, middle;
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; }
‫התוכנית הראשית‬
52
int main()
{
int arr[SIZE]={5,8,9,12,12,17,20,21,24,27,29,31};
int item=24, status=0;
status=binarySearch( arr,item);
if(status)
printf(“Item is found in array!!!\n");
else
printf(“Item is not found in array!!!\n");
return 0;
}
53
?‫שאלות‬

‫תרגילי כיתה (מערכים חד ממדים)‬
‫‪54‬‬
‫‪ .7‬כתוב תוכנית המגדירה המבצעת את המשימות הבאות‪:‬‬

‫• תגדיר מערך בגודל ‪ 10‬מטיפוס ממשי‪.‬‬
‫• תגדיר ותפעיל פונקציה לקליטת ‪ 10‬מספרים למערך‪.‬‬
‫• תגדיר ותפעיל פונקציה להדפסת המערך‪.‬‬
‫• תגדיר ותפעיל פונקציה למציאת המספר הגדול במערך‬
‫• תגדיר ותפעיל פונקציה למציאת המספר הקטן ביותר במערך‪.‬‬
‫• תגדיר ותפעיל פונקציה למציאת סכום כל איברי המערך‬
‫ולהחזרת הסכום לתוכנית הראשית‪.‬‬
‫• תגדיר ותפעיל פונקציה למציאת סכום הממוצע של כל איברי‬
‫המערך ולהחזרת הסכום לתוכנית הראשית‪.‬‬
‫‪55‬‬
‫‪ .8‬כתוב תוכנית המגדירה מערך בעל ‪ 10‬איברים‪ ,‬מגדירה ומפעילה‬

‫פונקציה לקליטת ‪ 10‬ערכים שלמים למערך‪.‬‬
‫כתוב פונקציה המקבלת את המערך מחשבת ומחזירה ‪ 1‬אם אחד‬
‫האיברים במערך מתחלק ב‪ 3 -‬וב‪ 7-‬ללא שארית‪ ,‬אחרת תחזיר ‪.0‬‬
‫‪ .9‬כתוב תוכנית המגדירה מערך של מספרים ממשים בגודל ‪.20‬‬
‫התוכנית תגדיר ותפעיל פונקציה לקליטת המספרים למערך‪.‬‬
‫התוכנית תגדיר ותפעיל פונקציה הבודקת ומדפיסה מהו המספר‬
‫הגדול ביותר ומיקומו במערך (מספר התא)‪.‬‬
‫התוכנית תגדיר ותפעיל פונקציה הבודקת ומדפיסה מהו המספר הקטן‬
‫ביותר ומיקומו במערך (מספר התא)‪.‬‬
‫‪56‬‬
‫‪ .10‬כתוב תוכנית המגדירה המבצעת את המשימות הבאות‪:‬‬

‫תגדיר שני מערכים בגודל ‪ 10‬מטיפוס שלם‪.‬‬ ‫•‬
‫תגדיר ותפעיל פונקציה לקליטת ‪ 10‬מספרים למערך הראשון‪.‬‬ ‫•‬
‫תגדיר ותפעיל פונקציה להעברת כל האיברים שבמערך‬ ‫•‬
‫הראשון אשר הינם מספרים ראשוניים למערך השני תוך כדי‬
‫שמירה על מיקומם המקורי במערך הראשון‪.‬‬
‫תגדיר ותפעיל פונקציה אשר תדפיס את שני המערכים לאחר‬ ‫•‬
‫ביצוע העברת הראשוניים מהמערך הראשון לשני‪.‬‬

‫מיון בועות למערך חד ממדי‬
57
#include <stdio.h> ‫הגדרת משתנה גלובלי לגודל‬

#define SIZE 10 ‫המערך‬
int sort(int numbers[ ]); ‫ביצוע הכרזות על שתי‬

:‫הפונקציות‬
int print(int numbers[ ]);
‫מיון והדפסה של המערכים‬
int main()
}
int numbers[SIZE];
int i;
printf("please enter 10 numbers:\n\n");

58
for(i = 0; i < SIZE; i++) ‫תוכנית ראשית המפעילה את‬

‫תהליך קליטת הערכים למערך‬
}
printf(“Enter number in place %d \n",i+1);
scanf("%d",&numbers[i]);
{
sort(numbers); ‫קריאה לפונקציית המיון‬
print(numbers); ‫קריאה לפונקציית ההדפסה‬
return 0;
{
‫‪59‬‬
‫)] [‪int sort(int numbers‬‬
‫{‬ ‫פונקציית המיון המבצעת את מיון הבועות‬
‫;‪int i, j, temp‬‬ ‫למערך שנקלט בתוכנית הראשית‬
‫)‪for (i = (SIZE-1); i >= 0; i--‬‬
‫)‪for (j = 1; j <= i; j++‬‬
‫{‬
‫)]‪if (numbers[j-1] > numbers[j‬‬
‫{‬
‫;]‪temp = numbers[j-1‬‬
‫;]‪numbers[j-1] = numbers[j‬‬
‫;‪numbers[j] = temp‬‬ ‫ביצוע מעבר על כל איברי המערך‬
‫}‬ ‫בלולאה כפולה כדי לוודא את‬
‫}‬ ‫היחס בין כל איבר לשכנו והחלפה‬
‫;‪eturn 0‬‬
‫ביניהם לפי הצורך‬
‫}‬
60
int print(int numbers] [( ‫פונקציית ההדפסה‬

}
int i;
printf(“\n\nSorted array:\n\n");
for(i = 0; i < SIZE; i++)
}
printf(“Array place number %d ", i);
printf(“Value %d \n", numbers[i]);
{
return 0;
{
‫העברת משתנים קבועים לפונקציה‬
‫‪61‬‬
‫‪ ‬אפשר להגדיר משתני קלט בפונקציה כקבועים (‪.)const‬‬
‫‪ ‬כך נוכל להבטיח שלא נשנה בטעות את ערך המשתנה‪.‬‬
‫‪ ‬הכי שימושי כאשר אנו מעבירים מערך לפונקציה‪.‬‬
‫‪‬לתשומת הלב ‪ -‬לא ניתן להעביר מערך שהוגדר כקבוע (‪)const‬‬
‫לפונקציה שבה הוא לא קבוע ועלול להשתנות !!!‬
‫)‪void print_array(const int array[], int size‬‬
‫{‬
‫;‪int i = 0‬‬
‫)‪for( i=0; i<size; i++‬‬
‫;)]‪printf("%3d",array[i‬‬
‫;)"‪printf("\n‬‬
‫}‬
62
?‫שאלות‬

‫מערכים רב‪-‬ממדיים(דו ממד)‬
‫‪63‬‬
‫‪ ‬משמשים לייצוג מטריצות‪ ,‬או מערכים בעלי ממד גבוה יותר‪.‬‬

‫‪ ‬הגדרה‪:‬‬
‫;]‪int arr[7][9‬‬
‫‪ ‬גישה לתא במערך דורשת שני אינדקסים‪:‬‬

‫;‪arr[5][8]=4‬‬
‫‪ ‬האינדקס הראשון [‪ ]5‬מציין מספר שורה והשני [‪ ]8‬מציין מספר‬
‫העמודה‪ ,‬יחד שני המספרים מצביעים על התא המבוקש‪.‬‬

‫אתחול מערכים רב ממדים‬
‫‪64‬‬
‫‪ ‬ניתן לאתחל בהגדרה‪:‬‬

‫;}}‪int my_matrix[3][2]={{1,0}, {0,1}, {1,1‬‬
‫‪ ‬אתחול נפוץ יותר הוא בעזרת לולאות מקוננות‪:‬‬

‫)‪void init_array(int array[][COL],int value‬‬
‫{‬
‫;‪int i=0,j=0‬‬ ‫בהעברת מערך רב ממדי‬
‫) ‪for(i=0;i<ROW;++i‬‬ ‫לפונקציה חייבים לכתוב‬
‫) ‪for(j=0;j<COL;++j‬‬ ‫את גודל הממד השני‬
‫;‪array[i][j]=value‬‬ ‫והלאה בראש הפונקציה‬
‫}‬
‫מערכים דו ממדים‬
‫‪65‬‬
‫ניתן להכליל את המערך הרגיל של ‪( C‬החד ממדי) למספר‬ ‫‪‬‬

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

‫‪66‬‬
‫‪66‬‬
‫עמודה ‪0‬‬ ‫עמודה ‪1‬‬ ‫עמודה ‪2‬‬ ‫עמודה ‪3‬‬
‫שורה ‪0‬‬ ‫]‪arr[0][0] arr[0][1] arr[0][2] arr[0][3‬‬
‫אינדקס עמודה‬
‫אינדקס שורה‬
‫שם המערך‬
‫‪67‬‬
‫‪67‬‬
‫אתחול מערך דו ממדי יתבצע כך‪:‬‬

‫)(‪int main‬‬
‫{‬ ‫אתחול שורה ‪ 2‬אתחול שורה ‪ 1‬אתחול שורה ‪0‬‬
‫;}}‪int arr[ROW][COL]={{1,2,3,4} , {5,6,7,8} , {9,10,11,12‬‬
‫}‬
‫‪0‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬
‫מספר עמודות‬
‫מספר שורות‬ ‫‪0‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬
‫שם המערך‬
‫‪1‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪7‬‬ ‫‪8‬‬
‫‪2‬‬ ‫‪9‬‬ ‫‪10‬‬ ‫‪11‬‬ ‫‪12‬‬

‫דוגמא לתוכנית עם מערכים דו ממדים‬
68
#include <stdio.h>
#define ROW 3
#define COLUMN 4
int main()
{
int arr[ROW][COLUMN]= {{1,2,3,4},{5,6,7,8},{9,10,11,12}}, i, j;
for ( i = 0; i < ROW; i++ )
{ ‫מעבר על השורות‬
for ( j = 0; j < COLUMN; j++ )
printf( "%4d", arr[ i ][ j ] ); ‫מעבר על תוכן העמודה‬
printf( "\n" );
} ‫הדפסת איברי השורה‬
return 0;
}
?‫מה עושה התוכנית הבאה‬
69
#include <stdio.h>
#define ROW 11 10 ‫ עד‬1 -‫מדפיסה את לוח הכפל מ‬
#define COL 11
int main()
{ ‫מכניסה לתוך המערך את תוצאת‬
int i ,j, arr[ROW][COL];
for(i=1; i<=ROW-1; i++) ‫המכפלה של מספר השורה כפול‬
for(j=1; j<=COL-1 j++) ‫מספר העמודה‬
arr[i][j] = i*j;
for(i=1; i<=ROW-1; i++)
{ ‫מדפיסה את ערכי התאים במערך‬
for(j=1; j<=COL-1; j++)
printf(“%4d”, arr[i][j]);
printf(“\n”);
}
return 0;
}
70
#include <stdio.h>
#define SIZE 3
void main()
}
int matrix[SIZE][SIZE]={0}, i, j, count;
for(count=1,i=0,j=SIZE/2;count<=SIZE*SIZE;count++)
}
if(i<0)
i+=SIZE;
if(j==SIZE)
j-=SIZE;
while(matrix[i][j])
}
71
i++;
3X3 ‫מדפיסה ריבוע קסם בגודל‬
j--;
if(i==SIZE) :‫התוכנית תדפיס ריבוע קסם‬
i-=SIZE; The array:
if(j<0) 4 3 8
j+=SIZE; 9 5 1
2 7 6
i++;
if(i==SIZE)
i-=SIZE;
{
matrix[i--][j++]=count;
}
72
printf("The M array:\n");
{
for(j=0;j<SIZE;j++)
printf("%4d",matrix[j][i]);
putchar('\n');
}
}

73
?‫שאלות‬

‫מערכים דו ממדים ופונקציות‬
‫‪74‬‬
‫‪74‬‬
‫כיצד נעביר מערך דו ממדי לפונקציה כך שהפונקציה‬ ‫•‬

‫תדע שמדובר במערך דו‪-‬ממדי?‬
‫יש להתבסס על תהליך העברת מערכים לפונקציות‬ ‫•‬
‫באופן כללי‬
‫כשדיברנו על מערכים רגילים העברנו מצביע (שם‬ ‫•‬
‫המערך) אל הפונקציה‪ ,‬בנפרד העברנו את גודלו‪.‬‬
‫מה נעביר לפונקציה בבואנו להעביר מערך דו ממדי ?‬ ‫•‬
‫יש להעביר רק את שמו של המערך‪ ,‬הוא מציין את‬ ‫•‬
‫המצביע לתא הראשון של המערך‪.‬‬

‫דוגמא לפונקציה המקבלת מערך דו ממדי‬
75
void printArrayZogi(int arr[][ COLUMN ] )

{
int i, j;
for ( i = 0; i < ROW; i++ ) ‫מעבר על השורות‬
{
if(arr[i][j]%2==0) ‫הדפסת איברי השורה‬
printf( "%4d", arr[ i ][ j ] ); ‫הזוגיים בלבד‬
printf( "\n" );
}
}
‫‪76‬‬
‫‪76‬‬
‫למערך דו ממדי מתייחסים כאלו הוא טבלה‪ ,‬אבל בזיכרון המחשב‬

‫המערך הדו ממדי מופיע כמערך רגיל‪.‬‬
‫כדי לפנות באמצעות פונקציה ולטפל באיברי המערך הדו ממדי עלינו‬
‫לפנות לכל תא באמצעות [ ] [ ]‪ ,‬כשהראשון מציין מספר שורה והשני‬
‫עמודה‪:‬‬
‫מציאות‬ ‫אשליה‬
‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬ ‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬ ‫‪1‬‬ ‫‪2‬‬ ‫‪3‬‬
‫‪4‬‬ ‫‪5‬‬ ‫‪6‬‬

77
77
,‫ תאים‬3 ‫ מכילה‬0 ‫ צריך לדעת שהשורה ה‬arr[1][1] ‫כדי לגשת לתא‬

:‫ למעשה מה שמתבצע בפועל זה‬, COLUMN=3
arr[row][col] arr[row*COLUMN+col]
‫מציאות‬
arr[1][1] arr[1*COLUMN+1]
‫אשליה‬
0 1 2 1 2 3 4 5 6
0 1 2 3 Column in row
row column
1 4 5 6
place is 4!!!
arr[1][1] arr[(1*3)+1]
‫דוגמא לתוכנית השולחת לפונקציה‬
‫מערך דו ממדי המודפס בתוכה‬
78
#include <stdio.h>
#define ROW 3
#define COL 4
void printArray(int [][ COL]);
int main()
{
int array1[ROW][COL]={{1,2,3,4},{5,6,7,8}, {9,10,11,12}};
printf( "Values in array1 by row are:\n" );
printArray( array1 );
return 0;
}
‫דוגמא לתוכנית השולחת לפונקציה‬
‫מערך דו ממדי המודפס בתוכה‬
79
void printArray(int arr[][ COLUMN ] )

{
int i, j;
for ( i = 0; i < ROW; i++ )
{
printf( "%4d", arr[ i ][ j ] );
printf( "\n" );
}
}
‫אלכסונים ראשי ומשני‪ ,‬משולשים מעל ומתחת‬
‫לאלכסונים‬
‫‪80‬‬
‫מטריצה בגודל ‪:‬‬

‫]‪arr[0][0‬‬ ‫]‪arr[0][1‬‬ ‫]‪arr[0][2‬‬
‫‪3X3‬‬
‫]‪arr[1][0‬‬ ‫]‪arr[1][1‬‬ ‫]‪arr[1][2‬‬
‫]‪arr[2][0‬‬ ‫]‪arr[2][1‬‬ ‫]‪arr[2][2‬‬
‫‪i == j‬‬ ‫אלכסון ראשי‪:‬‬ ‫‪.1‬‬

‫‪i<j‬‬ ‫משולש מעל אלכסון ראשי‪:‬‬ ‫‪.2‬‬
‫משולש מתחת לאלכסון ראשי‪i > j :‬‬ ‫‪.3‬‬
‫‪i + j == SIZE – 1‬‬ ‫אלכסון משני‪:‬‬ ‫‪.4‬‬
‫משולש מעל לאלכסון משני‪i + j < SIZE – 1 :‬‬ ‫‪.5‬‬
‫משולש מתחת לאלכסון משני‪i + j > SIZE - 1 :‬‬ ‫‪.6‬‬
81
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define SIZE 3
int main()
}
int i ,j, arr[SIZE][SIZE],fdigo=0,sdigo=0;
srand(time(NULL));
for (j = 0; j < SIZE; j++)
}
arr[i][j] = rand() % 10;
if(i==j) fdigo += arr[i][j];
if(i+j==SIZE-1) sdigo += arr[i][j];
}
82
printf("The array:\n"); The array:

for(i=0; i<SIZE; i++) 0 0 2
} 7 5 5
for(j=0; j<SIZE; j++) 3 0 6
printf("%4d", arr[i][j]); Answer 1: 11
printf("\n"); Answer 2: 10
{
printf("Answer 1: %d\n", fdigo);
printf("Answer 2: %d\n", sdigo);
return 0;
{
83
?‫שאלות‬

‫מערכים רב‪-‬ממדיים(תלת ממד)‬
‫‪84‬‬
‫‪ ‬משמשים לייצוג מטריצות תלת ממדיות‪.‬‬

‫;]‪int arr[7][9][5‬‬ ‫‪ ‬הגדרה‪:‬‬
‫‪ ‬המשמעות היא שלמערך זה ‪ 7‬שורות‪ 9 ,‬עמודות ו‪ 5-‬שורות‬
‫לעומק‪.‬‬
‫‪ ‬גישה לתא במערך כזה דורשת שלושה אינדקסים‪:‬‬
‫;‪arr[5][8][3]=25‬‬
‫‪ ‬האינדקס הראשון [‪ ]5‬מציין מספר שורה והשני [‪ ]8‬מציין מספר‬
‫העמודה‪ ,‬האינדקס השלישי [‪ ]3‬מציין את ממד העומק‪ ,‬יחד‬
‫שלושת המספרים מצביעים על התא המבוקש לתוכו נכניס ‪.25‬‬
‫מערכים תלת ממדים‬
‫‪85‬‬
‫‪ ‬ניתן להכליל את המערך הרגיל של ‪( C‬החד ממדי) בתוך‬

‫מספר מערכים רב ממדיים דו ותלת‪.‬‬
‫‪ ‬כל מערך חד ממדי או רב ממדי אחר מיוצג בזיכרון‬
‫המחשב באופן רציף‪ ,‬כך שגם תלת ממדי מיוצג באותה‬
‫צורה‪.‬‬
‫‪ ‬ניתן לחשוב על מערכים רב ממדיים כעל טבלה של עמודות‬
‫ושורות‪ ,‬כך שתלת ממד מוסיף ממד של שורות לעומק‪.‬‬
‫‪ ‬כל מערך רב ממדי ניתן לייצוג באמצעות מספר מערכים‬
‫חד ממדיים‪.‬‬
‫תרגיל בדו ממד ‪ +‬פתרון‬
‫‪86‬‬
‫‪86‬‬
‫מערכים רב ממדיים ניתנים לשימוש ככל מערך אחר‬ ‫•‬

‫והם מסוגלים לקלוט ערכים מכל טיפוס מוכר‪.‬‬
‫כתוב פונקציה המקבלת מערך דו מימדי בגודל ‪4X4‬‬ ‫•‬
‫המלא במספרים חיוביים‪.‬‬
‫הפונקציה תעבור על המערך תחשב ותציב בכל תא‬ ‫•‬
‫במערך את השורש של המספר שהיה בו במקור‪.‬‬
‫בהמשך כתוב תוכנית אשר מדפיסה את המערך המקורי‬ ‫•‬
‫לפני העברתו לפונקציה ואת המערך לאחר הפעלתו‬
‫וטיפולו בפונקציה‪.‬‬
‫פתרון לפונקציית הדפסת המערך‬
87
#include <stdio.h>
#include <math.h>
#define ROW 4
#define COLUMN 4
void printArray (float arr[][ COLUMN ] )

{
int i, j;
for ( i = 0; i < ROW; i++ )
{
printf(“%8.2f”,arr[i][j]);
printf(“\n”);
}
}
‫פתרון לפונקציית חישוב השורשים‬
88
void fillArraySqrt(float arr[][ COLUMN ] )
{
int i, j;
for ( i = 0; i < ROW; i++ )
arr[ i ][ j ] = sqrt(arr[i][j]);
}

‫פתרון לתוכנית הראשית‬
89
int main()
{
float array[ ROW ][ COLUMN ] = }11,121,31,81{
}}19,10,11,12{,}15,61,17,81{, }11,12,31,144{,;
printf( “Original Matrix Values are:\n" );
printArray(array);
fillArraySqrt(array);
printf( “Array Sqrt Values are:\n" );
printArray(array);
return 0;
}
90
?‫שאלות‬

‫מיון בועות למערך דו ממדי‬
91
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define ROWS 3
#define COLUMN 3
/*function prototype*/
void printArray(int [][COLUMN]);
void initRandomValues (int [][COLUMN]);
void bubblesort(int [][COLUMN]);
92
void main()
{
int arr[ROWS][COLUMN];
srand(time(NULL));
initRandomValues(arr);
printf("The array before bubble sort:\n");
printf("=======================\n");
printArray (arr);
bubblesort(arr);
printf("The array after bubble sort:\n");
printf("======================\n");
printArray(arr);
}
93
void initRandomValues(int arr[][COLUMN])

{
int i,j;
for(i=0;i<ROWS;i++)
{
for(j=0;j<COLUMN;j++)
{
arr[i][j]=rand()%100;
}
}
}
94
void printArray(int arr[][COLUMN])

{
int i, j;
for(i=0;i<ROWS;i++)
{
for(j=0;j<COLUMN;j++)
printf("%5d",arr[i][j]);
printf("\n");
}
printf("\n");
}
95
void bubblesort(int data[][COLUMN])

{
int i, j, k, temp;
for (k = 0; k < ROWS * COLUMN; k++)
{
for (i = 0; i < ROWS; i++)
{
for (j = 0; j < COLUMN; j++)
{

96
if ((data[i][j] > data[i][j + 1]) && j != COLUMN - 1)

{
temp = data[i][j];
data[i][j] = data[i][j + 1];
data[i][j + 1] = temp;
}
if ((data[i + 1][0] < data[i][j]) && (i != ROWS - 1))
{
temp = data[i + 1][0];
data[i + 1][0] = data[i][j];
data[i][j] = temp;
}
}}}}
‫סיכום‬
‫‪97‬‬
‫הצורך במערך‪ ,‬מערך ושימושיו‬ ‫‪‬‬

‫הגדרת מערכים‪ ,‬אתחול מערכים‬ ‫‪‬‬
‫גישה לתאים באופן סודר‪ ,‬גישה לתאים באופן ישיר‬ ‫‪‬‬
‫העברת מערך לפונקציה‬ ‫‪‬‬
‫עדכון נתוני מערך חד ממדי בפונקציה‪ ,‬סידור‪ ,‬מיון (מיון בועות)‬ ‫‪‬‬
‫מערכים רב‪-‬ממדיים‬ ‫‪‬‬
‫העברת מערכים רב ממדיים לפונקציה‪.‬‬ ‫‪‬‬
‫חיפוש לינארי וחיפוש בינארי במערך חד ממדי‬ ‫‪‬‬
‫מיון מערך דו‪-‬ממדי (מיון בועות)‬ ‫‪‬‬

98
?‫שאלות‬

‫‪99‬‬
‫‪ .11‬כתוב תוכנית הקולטת מהמשתמש ‪ 10‬מספרים שלמים למערך ‪.arr‬‬

‫התוכנית יוצרת מערך חדש ‪ ,brr‬המורכב מהמספרים השליליים‬
‫במערך ‪ ,arr‬ומערך חדש נוסף ‪ crr‬הבנוי מהמספרים החיוביים‬
‫במערך ‪( .arr‬המערכים ‪ brr‬ו‪ crr-‬יוגדרו בגודל ‪ ,10‬ומאופסים‬
‫בתחילה)‪.‬‬
‫‪ .12‬כתוב תוכנית המגדירה מערך דו ממדי ‪ NxN‬ומציבה בתוכו ‪16‬‬
‫איברים אקראיים שלמים ותדפיס אותו‪ .‬התוכנית תגדיר ותפעיל‬
‫פונקציה שתחזיר ‪ 0‬כאשר המערך מכיל אך ורק מספרים זוגיים ו‪1 -‬‬
‫כאשר יש בו ערך אחד לפחות שאינו זוגי‪.‬‬
‫כמו כן התוכנית תגדיר ותפעיל פונקציה שתדפיס את המטריצה על המסך‬
‫כאשר השורות האי זוגיות יודפסו מהסוף להתחלה והשורות הזוגיות‬
‫מתחילתן ועד סופן‪.‬‬
‫‪100‬‬
‫‪ .13‬כתוב תוכנית שתגדיר מערך דו ממדי בגודל ‪ .5X5‬בנוסף התוכנית‬

‫תקלוט מהמשתמש ערך נוסף לחיפוש‪.‬‬
‫התוכנית תבצע את המשימות הבאות‪:‬‬
‫תמלא את המערך הדו ממדי במספרים אקראיים ותדפיס אותו‪.‬‬ ‫א‪-‬‬
‫תבצע מיון למערך הדו ממדי ותדפיס את המערך הממוין‪.‬‬ ‫ב‪-‬‬
‫תבצע חיפוש בינארי בתוך המערך הממוין למציאת הערך הנוסף‬ ‫ג‪-‬‬
‫שנקלט‪ ,‬במידה והערך נמצא במערך יודפס מיקומו במערך במידה ולא‪,‬‬
‫תודפס הודעה מתאימה‪.‬‬
‫תבצע חיפוש לינארי בתוך המערך הממוין למציאת הערך הנוסף‬ ‫ד‪-‬‬
‫שנקלט‪ ,‬במידה והערך נמצא במערך יודפס מיקומו במערך במידה ולא‪,‬‬
‫תודפס הודעה מתאימה‪.‬‬
‫הערה‪ :‬יש לבצע כל משימה באמצעות פונקציה ייחודית עבורה‪.‬‬
‫‪101‬‬
‫‪ .14‬כתוב תוכנית שתגדיר מערך דו ממדי בגודל ‪ .3X3‬התוכנית‬

‫תבצע שחלוף‪ ,‬כלומר תהפוך את השורות לעמודות‪ .‬יש להשתמש‬
‫לצורך השיחלוף בפונקציה‪.‬‬
‫תבצע בדיקה באמצעות פונקציה האם המערך הוא מערך סימטרי‬
‫כלומר כל איברי המערך לפני ואחרי שיחלוף נמצאים באותו‬
‫מקום ותחזיר תשובה ‪ 1‬אם כן ו‪ 0 -‬אם לא‪.‬‬
‫תבצע את המשימות הבאות באמצעות פונקציות‪:‬‬
‫• תחשב ותחזיר מהו ממוצע כל השורות הזוגיות‪.‬‬
‫• תחשב ותדפיס מהו ממוצע כל העמודות האי זוגיות‪.‬‬

פרק 7 - מערכים

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

פרק 7 - מערכים

Uploaded by

Copyright:

Available Formats

‫קורס יסודות התכנות בשפת ‪C‬‬

‫ד"ר שייקה בילו‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪1‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫>‪#include <stdio.h‬‬ ‫אל פונקציה מועבר הערך של המשתנה‬

‫)‪int count(int mis‬‬

‫‪ ‬כדי להשתמש בפונקציה‪ ,‬צריך שהיא תהיה מוגדרת‪.‬‬

:(declaration, prototype( ‫ דוגמא להכרזה‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

:‫הפונקציה כוללת את כל הפעילות הנדרשת כמו בתוכנית‬

?‫שאלות על השעור הקודם‬

SCE-Chapter-7-Arrays Shayke Bilu PhD

‫‪ ‬יש צורך לבנות מערכת בדיקה המבצעת את המשימות הבאות‪:‬‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬נרצה לבצע מספר רב של פעולות זהות על מספר רב של משתנים‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫לכל המשתנים יש שם משותף ואינדקס (מספר סידורי)‪.‬‬ ‫•‬

‫בעזרת השם והאינדקס ניתן לגשת למשתנה מסוים באוסף‪.‬‬ ‫•‬

‫‪9‬‬ ‫‪.‬‬ ‫‪. . . 5 . . . 7‬‬

‫שינוי אינדקס הגישה‪:‬‬

SCE-Chapter-7-Arrays Shayke Bilu PhD

‫הגדרת המושג מערך והצורך בו‬ ‫‪‬‬

‫‪ ‬ניתן לגשת לתא במערך ע"י כתיבת שם המערך ומספרו‬

‫‪ ‬הערכים מוצבים בתאים לפי הסדר החל מהתא הראשון‪.‬‬

‫‪ ‬ניתן להגדיר מערכים בצורה זו אך ורק בשורת ההגדרה‪:‬‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬אחרי הגדרת המערך אפשר להתייחס לכל תא בנפרד‪.‬‬

‫‪ ‬מותר לגשת לכל תא במערך לפי כתובתו‪ ,‬בתנאי שהכתובת שייכת‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬בהגדרת מערך הגודל שלו חייב להיות מספר קבוע‪ ,‬ולא‬

‫;‪int my_size=10‬‬ ‫ולא‪:‬‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬גודל מערך יכול להיות קבוע שמוגדר ב‪#define -‬‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫● משמעות הגדרת מערך – הטיפוס‪ ,‬הגודל‪ ,‬השימוש‬

SCE-Chapter-7-Arrays Shayke Bilu PhD

‫‪ .1‬כתוב תוכנית המגדירה מערך בעל ‪ 10‬איברים‪ ,‬קולטת לתוכו‬

‫‪ .2‬כתוב תוכנית המגדירה שני מערכים בגודל ‪ 10‬וקולטת לתוכם‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ .3‬כתוב תוכנית המגדירה מערך בעל ‪ 10‬איברים‪ ,‬קולטת לתוכו‬

‫‪ .5‬כתוב תוכנית המגדירה שני מערכים בגודל ‪ 10‬וקולטת לתוכם‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

SCE-Chapter-7-Arrays Shayke Bilu PhD

‫‪ ‬אפשר להעביר לפונקציה מערכים מכל הסוגים‬

‫‪ ‬בשונה ממשתנים אחרים העברת המערך ייחודית‪:‬‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪ ‬אין צורך לציין את גודל המערך בתוך ה‪ ] [ -‬בכותרת הפונקציה‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

void minarr(int arr[ ])

void sumarr(int arr[ ])

SCE-Chapter-7-Arrays Shayke Bilu PhD

SCE-Chapter-7-Arrays Shayke Bilu PhD

‫נתון מערך ממוין נרצה לחפש בו איבר כלשהו‪.‬‬

‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 24 27 29 31‬‬

‫נחפש את ‪ 17‬חיפוש רגיל‪ ,‬לינארי‪ ,‬על כל‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫נתון מערך ממוין נרצה לחפש בו איבר כלשהו‪.‬‬

‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 24 27 29 31‬‬

‫נחפש את ‪ 24‬חיפוש בינארי‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

‫‪5‬‬ ‫‪8‬‬ ‫‪9‬‬ ‫‪12 15 17 20 21 23 24 29 31‬‬

‫נחפש את ‪ 24‬חיפוש בינארי‬

‫‪SCE-Chapter-7-Arrays‬‬ ‫‪Shayke Bilu PhD‬‬

SCE-Chapter-7-Arrays Shayke Bilu PhD