‫מערך דו‪-‬ממדי‬

‫חיפוש‪ ,‬מיון‪ ,‬מיזוג‬

‫ואהבת לרעך כמוך‬
 ‫בסוף הפרק‬
‫תבינו מה היתרון להשתמש במערכים דו‪-‬ממדים‬ ‫‪‬‬

‫תכתבו קוד המשמש במערך דו‪-‬ממדי‬ ‫‪‬‬

‫תצליחו לבצע חיפוש בתוך מערך‬ ‫‪‬‬

‫תמיינו מערך בצורה יעילה‬ ‫‪‬‬

‫תמזגו בין ‪ 2‬מעכרים‬ ‫‪‬‬

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

‫ג'ויס ווגל‬ ‫‪4‬‬

void swap(float vec[], int size, int i,int j)
{
float help=vec[i];
vec[i]=vec[j];
vec[j]=help;
}

‫ג'ויס ווגל‬ 5
int main(){
float array[10];
cout<<"enter 10 numbers: "<<endl;
for(int i=0;i<10;i++)
cin>>array[i];
swap(array,10,3,7);
for(int i = 0; i < 10; i++)
cout<<array[i]<<' ';
return 0;
}

‫ג'ויס ווגל‬ 6
 ‫‪ ‬אפשר בעצם לשמור מערכים בתוך מערכים‬
‫‪ ‬לדוגמה‪:‬‬
‫;]‪int array[2][3‬‬
‫בעצם בונה את המבנה הבא‪:‬‬

‫ג'ויס ווגל‬ ‫‪7‬‬

 ‫כמה בתים בזיכרון זה תופס?‬

‫ג'ויס ווגל‬ ‫‪8‬‬

 ‫כמה בתים בזיכרון זה תופס?‬
‫כל תא הוא ‪ 4‬בתים‬
‫כל מערך פנימי ‪ 4‬כפול ‪ 3‬שווה ‪ 12‬בתים‬
‫יש ‪ 2‬מערכים פנימיים‬
‫‪ 12‬כפול ‪ 2‬שווה ‪ 24‬בתים‬
‫ג'ויס ווגל‬ ‫‪9‬‬
‫אם מהמספר הראשון שמור בכתובת ‪ 1000‬אז באיזה כתובת‬
‫שומרים את המספר האחרון?‬

‫ג'ויס ווגל‬ ‫‪10‬‬

‫אם מהמספר הראשון שמור בכתובת ‪ 1000‬אז באיזה כתובת‬
‫שומרים את המספר האחרון?‬

‫‪1020‬‬

‫ג'ויס ווגל‬ ‫‪11‬‬

‫ואם היה נתון מערך של ‪-char‬ים‬
‫כמה בתים בזיכרון זה תופס?‬

‫ג'ויס ווגל‬ ‫‪12‬‬

‫ואם היה נתון מערך של ‪-char‬ים‬
‫כמה בתים בזיכרון זה תופס?‬
‫‪ 6‬בתים‬

‫ג'ויס ווגל‬ ‫‪13‬‬

‫בדרך כלל יותר קל להציג מערך דו‪-‬ממדי כמטריצה (טבלה)‬ ‫‪‬‬

‫;]‪ int array[2][3‬‬

‫ג'ויס ווגל‬ ‫‪14‬‬

‫בדרך כלל יותר קל להציג מערך דו‪-‬ממדי כמטריצה (טבלה)‬ ‫‪‬‬

‫;]‪ int array[2][3‬‬

‫שורות‬ ‫עמודות‬

‫ג'ויס ווגל‬ ‫‪15‬‬

 ‫עבור כל שורה‬ ‫‪‬‬

‫‪ ‬לקלוט ערך עבור כל עמודה‬

‫ג'ויס ווגל‬ ‫‪16‬‬

int i = 0;
for(int j = 0; j < cols; j++)
cin >> matrix[i][j];

‫ג'ויס ווגל‬ 17
for(int i = 0; i < rows; i++)
for(int j = 0; j < cols; j++)
cin >> matrix[i][j];

‫ג'ויס ווגל‬ 18
 ‫עבור כל שורה‬ ‫‪‬‬

‫להדפיס כל ערך השמור בכל עמודה‬ ‫‪‬‬

‫לעבור לשורה הבאה (להדפיס ‪)endl‬‬ ‫‪‬‬

‫ג'ויס ווגל‬ ‫‪19‬‬

int i = 0;
for(int j = 0; j < cols; j++)
cout << matrix[i][j];
cout << endl;

‫ג'ויס ווגל‬ 20
for(int i = 0; i < rows; i++){
for(int j = 0; j < cols; j++)
cout << matrix[i][j];
cout << endl;
}

‫ג'ויס ווגל‬ 21
‫לכתוב את הקוד שיבנה לוח כפל ממספרים ‪ 0‬עד ‪ 5‬כולל‪.‬‬

‫ג'ויס ווגל‬ ‫‪22‬‬

‫קודם נגדיר את המערך שישמור את לוח הכפל‪.‬‬ ‫‪‬‬

‫הלוח הוא ‪6x6‬‬ ‫‪‬‬

‫ולכן צריכים מערך עם‬ ‫‪‬‬

‫‪ 6 ‬שורות‬
‫‪ ‬וגם ‪6‬עמודות‪.‬‬

‫ג'ויס ווגל‬ ‫‪23‬‬

 ‫קודם נגדיר את המערך שישמור את לוח הכפל‪.‬‬ ‫‪‬‬

‫הלוח הוא ‪6x6‬‬ ‫‪‬‬

‫;]‪int mult[6][6‬‬

‫ג'ויס ווגל‬ ‫‪24‬‬

i = 0;
for (j=0; j<6; j++)
mult[i][j]=i*j;

‫ג'ויס ווגל‬ 25
i = 1; i = 3;
for (j=0; j<6; j++) for (j=0; j<6; j++)
mult[i][j]=i*j; mult[i][j]=i*j;

i = 4;
i = 2;
for (j=0; j<6; j++)
for (j=0; j<6; j++)
mult[i][j]=i*j;
mult[i][j]=i*j;
i = 5;
for (j=0; j<6; j++)
mult[i][j]=i*j;

‫ג'ויס ווגל‬ 26
for(i = 0; i < 6; i++)
for (j=0; j<6; j++)
mult[i][j]=i*j;

‫ג'ויס ווגל‬ 27
int mult[6][6];

for(i = 1; i < 6; i++)

for (j=1; j<6; j++)
mult[i][j]=i*j;

‫ג'ויס ווגל‬ 28
‫כתבו תוכנית המחשבת ומדפיסה לוח כפל מ‪ 1-10‬כולל‬

‫ג'ויס ווגל‬ ‫‪29‬‬

#include <iostream> for (i=1;i<=10;i++){
using namespace std; for (j=1;j<=10;j++)
int main(){ cout<<mult[i][j]<<'\
int mult[11][11]; t';
int i,j; cout<<endl;
for (i=1;i<=10;i++) }
for (j=1;j<=10;j++) return 0;
mult[i][j]=i*j; }

‫ג'ויס ווגל‬ 30
 ‫נתון מערך בשם ‪ vector‬המכיל מספרים הממוין בסדר‬ ‫‪‬‬

‫עולה‪.‬‬
‫איבר האחרון במערך שמור באינדקס ‪.n‬‬ ‫‪‬‬

‫רוצים להכנים את הערך ‪ num‬במקום הנכון בתוך המערך‬ ‫‪‬‬

‫כתבו את קטע הקוד שיבצע את הנדרש‪.‬‬ ‫‪‬‬

‫ג'ויס ווגל‬ ‫‪31‬‬

cin>>num;
for(int i = n; i>=0; i--)
if(vector[i]>num)
vector[i+1]=vector[i];
vector[i+1]=num;

‫ג'ויס ווגל‬ 32
 cin>>num;
i=n;
while(vector[i]>num && i>=0)
{
vector[i+1]=vector[i];
i--;
}
vector[i+1]=num;

‫ג'ויס ווגל‬ 33
‫כששולחים מערך כלשהו (כולל מערך דו ממדי) רק כותבים‬ ‫‪‬‬

‫את שם המערך‬
‫לדומגה‪:‬‬ ‫‪‬‬

‫;]‪int m[3][4‬‬
‫;)‪foo(m, 3, 4‬‬

‫ג'ויס ווגל‬ ‫‪34‬‬

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

‫מספר בתוך האינדקס של עמודות‬

‫לדומגה‪:‬‬ ‫‪‬‬

‫{)‪void foo(int table[][4],int rows, int cols‬‬

‫}‬

‫ג'ויס ווגל‬ ‫‪35‬‬

 ‫דוגמה‬ ‫‪‬‬

‫‪int array[3]= {6,1,8},‬‬

‫ג'ויס ווגל‬ ‫‪36‬‬

 ‫מאתחלים כל שורה על יד כתיבת {}‬ ‫‪‬‬

‫דוגמה‬ ‫‪‬‬

‫‪int matrix [3][3]={ {6,1,8},‬‬

‫‪{7,5,3},‬‬
‫;}}‪{2,9,4‬‬

‫ג'ויס ווגל‬ ‫‪37‬‬

‫רבוע קסם הוא ריבוע שסכום של כל המספרים בכל שורה‪,‬‬ ‫‪‬‬

‫בכל עמודה‪ ,‬ובכל אלכסון הם שווים‪.‬‬

‫ג'ויס ווגל‬ ‫‪38‬‬

int main(){
int magic[3][3]={ {6,1,8},
{7,5,3},
{2,9,4}};
int i,j,sum;
sum=getFirstRow(magic);

‫ג'ויס ווגל‬ 39
if (testRows(magic,sum) &&
testColumns(magic,sum) &&
testMainDiagonal(magic,sum) &&
testSecondDiagonal(magic,sum))
cout<<"magic square";
else
cout<<"not a magic square";
return 0;
}

‫ג'ויס ווגל‬ 40
bool testRows(const int magic[][3], int sum) {
for (int i=1;i<3;i++) {
int tmp=0;
for (int j=0;j<3;j++)
tmp+=magic[i][j];
if (tmp!=sum)
return false;
}
return true;
}
‫ג'ויס ווגל‬ 41
bool testColumns(const int magic[][3], int sum){
for (int j=0;j<3;j++) {
int tmp=0;
for (int i=0;i<3;i++)
tmp+=magic[i][j];
if (tmp!=sum)
return false;
}
return true;
}
‫ג'ויס ווגל‬ 42
bool testMainDiagonal(const int magic[][3], int
sum){
int tmp=0;
for (int i=0;i<3;i++)
tmp+=magic[i][i];
return tmp==sum;
}

‫ג'ויס ווגל‬ 43
bool testSecondDiagonal(const int magic[][3], int
sum)
{
int tmp=0;
for (int i=0, j=2; i<3; i++,j--)
tmp+=magic[i][j];
return tmp==sum;
}

‫ג'ויס ווגל‬ 44
 ‫נתון מערך וגודלו ורוצים לדעת האם מספר מסוים מופיע‬
‫במערך? אם כן מדפיס את מקומו ואם לא אז מדפיס הודעה‬
‫מתאימה‬

‫ג'ויס ווגל‬ ‫‪45‬‬

 ‫כל עוד שלא הגענו לסוף המערך וגם לא מצאנו את המספר‬ ‫‪‬‬

‫‪ ‬לעבור לתא הבא במערך‬

‫כשיוצאים מהלולאה בודקים למה יצאו מהלולאה‬ ‫‪‬‬

‫אם יצאנו כי מצאנו המספר אז להדפיס את האינדקס שבו‬ ‫‪‬‬

‫המספר נמצא‬
‫אם יצאנו כי הגענו לסוף המערך אז להדפיס הודעה שזה לא‬ ‫‪‬‬

‫נמצא‬

‫ג'ויס ווגל‬ ‫‪46‬‬

bool linearSearch(int a[], int n, int num){
for(int i = 0; i < n; i++)
if (a[i]==num)
return true;
return false;
}

‫ג'ויס ווגל‬ 47
int linearSearch(int a[], int n, int num){
for(int i = 0; i < n; i++)
if (a[i]==num)
return i;
return -1;
}

‫ג'ויס ווגל‬ 48
int linearSearch(int a[], int n, int num){
for(int i = 0; i < n; i++)
if (a[i]==num) ‫כי אינדקס שלילי במערך‬
return i;
return -1;
}

‫ג'ויס ווגל‬ 49
#include <iostream>
using namespace std; int main(){
int vec[8]={1,23,17,9,21,32,4,5};
int linearSearch(int a[], int n, int num)
int i=0, num;
{
cout<<"please enter a number\n";
for(int i = 0; i < n; i++)
if (a[i]==num)
cin>>num;
return i; int index = linearSearch(vector, 8);
return -1; if(index == -1)
} cout << “Not found”;
else
cout << “Found at position”
<< index;
}

‫ג'ויס ווגל‬ 50
‫אם המערך כבר ממוין אז חבל לעבור על כל המערך‬ ‫‪‬‬

‫מהתתחלה עד הסוף‬
‫נתחיל באמצא‬ ‫‪‬‬

‫אם איבר אמצעי שווה לערך שחיפשנו‬ ‫‪‬‬

‫‪ ‬אז מצאנו את הערך במערך‬

‫אם איבר האמצאי גדול מהערך שחיפשנו‬ ‫‪‬‬

‫אז להמשיך לחפש בצד שמאל של המערך‬ ‫‪‬‬

‫אם איבר האמצאי קטו מהערך שחיפשנו‬ ‫‪‬‬

‫אז להמשי לחפש בצד ימין של המערך‬ ‫‪‬‬

‫נמשיך לחפש כל עוד שהמערך גדול שווה ל‪0‬‬ ‫‪‬‬

‫ג'ויס ווגל‬ ‫‪51‬‬

bool binarySearch(int vec[],int size,int num){
int left=0,right=size-1,mid;
while (left<=right) {
mid=(left+right)/2;
if (vec[mid]<num)
left=mid+1;
else if (vec[mid]>num)
right=mid-1;
else return true;
}
return false;
}
‫ג'ויס ווגל‬ 52
‫יש שני מערכים ממוינים ורוצים למזג למערך אחד ממוין‬ ‫‪‬‬

‫ג'ויס ווגל‬ ‫‪53‬‬

 ‫כל עוד שנשאר ערכים ב‪ 2-‬המערכים‬ ‫‪‬‬

‫אם האיבר הבא במערך הראשון קטן מהאיבר הבא במערך השני‬ ‫‪‬‬
‫‪ ‬להעתיק את האיבר מהמערך הראשון למערך החדש‬
‫‪ ‬לקדם לאיבר הבא במערך הראשון‬
‫‪ ‬אחרת‬
‫‪ ‬להעתיק את האיבר מהמערך השני למערך החדש‬
‫‪ ‬לקדם לאיבר הבא במערך השני‬

‫ג'ויס ווגל‬ ‫‪54‬‬

 ‫אם הגיע לסוף מערך הראשון‬ ‫‪‬‬

‫להעתיק את כל האיבר הנשארים במערך השני למערך החדש‬ ‫‪‬‬

‫אחרת‬ ‫‪‬‬

‫להעתיק את כל האיבר הנשארים במערך הראשון למערך החדש‬ ‫‪‬‬

‫ג'ויס ווגל‬ ‫‪55‬‬

#include <iostream >
using namespace std;
int main(){

int vec1[5]={1,4,6,7,9};
int vec2[7]={2,4,5,6,7,8,10};
int vec3[12];
int i=0,j=0,k=0;

‫ג'ויס ווגל‬ 56
while (i<5 && j<7)
{
if (vec1[i]<vec2[j])
vec3[k]=vec1[i++];
else vec3[k]=vec2[j++];
k++;
}

‫ג'ויס ווגל‬ 57
while (i<5)
vec3[k++]=vec1[i++];
while (j<7)
vec3[k++]=vec2[j++];
for(i=0;i<12;i++)
cout<<vec3[i]<<' ';
return 0;
}

‫ג'ויס ווגל‬ 58
 https://www.geeksforgeeks.org/bubble-sort/

 7, 8, 5, 4, 2, 6, 3

‫ג'ויס ווגל‬ 59
void bubbleSort(int vec[],int size){
int last,i;
for (last = size-1; last > 0; last--)
for (int i = 0; i < last; i++)
if (vec[i+1] < vec[i]){
int temp = vec[i+1];
vec[i+1] = vec[i];
vec[i] = temp;
}
}

‫ג'ויס ווגל‬ 60
 https://www.geeksforgeeks.org/insertion-sort
/

 7, 8, 5, 4, 2, 6, 3

‫ג'ויס ווגל‬ 61
void insertSort(int vec[],int size){
int first,i;
for (first = 1; first < size; first++) {
int tmp = vec[first];
for (i=first; i > 0 && tmp < vec[i-1]; i--)
vec[i] = vec[i-1];
vec[i] = tmp;
}
}
‫ג'ויס ווגל‬ 62
 ‫‪>include <algorithm#‬‬ ‫‪‬‬

‫יש בספריה הרבה פונקציות שימושיות‬ ‫‪‬‬

‫ראשון שנסתכל עלין הוא ‪sort‬‬ ‫‪‬‬

‫ג'ויס ווגל‬ ‫‪63‬‬

 sort(‫ סוף המערך‬+ ‫ שם‬,‫)שם‬

 sort(array, array + 5);

‫ג'ויס ווגל‬ 64
#include <iostream >
#include <algorithm>
using namespace std;
int main()
{
int size = 5;
int arr[] = { 1, 6, 2, 9, 3 };
sort(arr, arr + size);

cout << "after sorting ";

for (int num : arr)
cout << num << " ";
cout << endl;
return 0;
}

‫ג'ויס ווגל‬ 65