1. מערכים ומטריצות
קרן כליף

2. אגב, נכון שזה נכון?? אז די! 2
© Keren Kalif

3. ביחידה זו נלמד: מהו מערך כיצד מערך נראה בזיכרון גישה לאיברי המערך
אתחול מערך
חריגה מגבולות המערך
השמת מערכים
מערך דו-מימדי
מערך רב-מימדי
לולאת for-each 3
© Keren Kalif

4. מוטיבציה
אם נרצה לכתוב תוכנית הקוראת 20 מספרים ומציגה את הממוצע שלהם, נצטרך להגדיר 20 משתנים:
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int num1, num2…num20, sum=0;
System.out.println(“Please insert 20 numbers: “);
num1 = s.nextInt();
num2 = s.nextInt();
…..
num20 = s.nextInt();
sum = num1 + num2 + … + num20;
System.out.println(“The average is ” + sum/20.0); }
התוכנית מסורבלת ומייגע לכתוב אותה, בייחוד כי יתכן גם שנרצה ממוצע של 100 מספרים, או אפילו יותר... 4
© Keren Kalif

5. הגדרה מערך הוא אוסף של משתנים מאותו הסוג עם שם אחד, ובעלי תפקיד זהה
מערך הוא אוסף של משתנים מאותו הסוג עם שם אחד, ובעלי תפקיד זהה
דוגמא: מערך של 20 מספרים
int[ ] numbers = new int[20];
דוגמא: מערך של 10 תוים
char[ ] letters = new char[10];
ובאופן כללי: <type>[ ] <var_name> = new <type>[SIZE];
איברי המערך נשמרים ברצף בזיכרון
גודל המערך בזיכרון: *SIZE<גודל הטיפוס> 5
© Keren Kalif

6. ערכם של איברי המערך שהוקצה הוא 0
דוגמא למערך בזיכרון
public static void main(String[] args) {
int x = 4;
int[ ] arr = new int[3];
char ch = ‘a’; }
int:x 4
int[]:arr
char: ch
‘a’
ערכם של איברי המערך שהוקצה הוא 0 6
© Keren Kalif

7. גישה לאיברי המערך מתייחסים ל- arr[0] כמו שמתייחסים ל- int
כדי שניתן יהיה להתייחס לכל איבר בנפרד ניתנו להם אינדקסים
האיבר הראשון בעל אינדקס 0, השני בעל אינדקס 1 והאחרון עם אינדקס SIZE-1
דוגמא:
int[ ] arr = new int[3];
arr[0] = 1;
הפניה לאיבר מסוים במערך היא ע"י [ ] כאשר בתוך הסוגריים יהיה האינדקס של האיבר אליו נרצה לגשת
פניה לאיבר במערך היא כפניה למשתנה מטיפוס המערך
מתייחסים ל- arr[0] כמו שמתייחסים ל- int 7
© Keren Kalif

8. גישה לאיברי המערך - דוגמא
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 4;
arr[1] = 7;
arr[2] = 3;
System.out.printf(“The values in the array: %d %d %d\n”,
arr[0], arr[1], arr[2]); } 4 7 4 4 7 3
int[]:arr 8
© Keren Kalif

9. מספר האיברים המערך למערך ישנו נתון המעיד על גודלו:
public static void main(String[] args) {
int[] arr = new int[4];
System.out.printf("There are %d numbers in the array\n", arr.length); } 9
© Keren Kalif

10. גישה לאיברי המערך - לולאות
מאחר ועבודה עם איברי המערך היא עבודה זהה על כל האיברים, יותר חסכוני וקל להשתמש בלולאות
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int[ ] arr = new int[5];
System.out.printf("Please enter %d numbers: ", arr.length);
for (int i=0 ; i < arr.length ; i++)
arr[i] = s.nextInt();
System.out.println("The numbers are: ");
System.out.printf("%d ", arr[i]);
System.out.println(); }
נשים לב שבעבודה עם מערכים ולולאות i יתחיל מ- 0
האינדקס שאיתו פונים לאיבר במערך יכול להיות:
מספר שלם (כמו בדוגמא הקודמת)
משתנה (כמו בדוגמא זו)
ערך של ביטוי, למשל: arr[i+2]
ניתוח זמן הריצה של תוכנית זו:
O(main) = O(1) + O(SIZE) + O(SIZE) = O(1) + 2*O(SIZE) = O(SIZE) 10
© Keren Kalif

11. גישה לאיברי המערך – לולאות (2)
הפעם נרצה להדפיס את איברי המערך מהסוף להתחלה..
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int[ ] arr = new int[5];
System.out.printf("Please enter %d numbers: ", arr.length);
for (int i=0 ; i < arr.length ; i++)
arr[i] = s.nextInt();
System.out.print("The numbers are: ");
for (int i=arr.length-1 ; i >= 0 ; i--)
System.out.printf("%d ", arr[i]);
System.out.println(); } 11
© Keren Kalif

12. גישה לאיברי המערך – לולאות - דוגמא
תוכנית המוצאת את הערך המקסימלי שהוכנס:
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int[ ] arr = new int[4];
System.out.printf("Please enter %d numbers: ", arr.length);
for (int i=0 ; i < arr.length ; i++)
arr[i] = s.nextInt();
int max = arr[0];
for ( ; ; ) {
if (arr[i] > max)
max = arr[i]; }
System.out.println("The max is “ + max); 13 11 17 15
int[]:arr
int: i 1
int: max 13
int[]:arr
int: i 2
int: max 17
int[]:arr
int: i 2
int: max 13
int[]:arr
int: i
???
int: max 13
int[]:arr
???
int: i
int: max
int[]:arr
int: i
???
int: max
int[]:arr
int: i 3
int: max 17
int[]:arr
int: i 4
int: max 17
int i=1
i < arr.length
i++
ניתוח זמן הריצה של תוכנית זו:
O(main) = O(1) + O(SIZE) + O(SIZE) = O(1) + 2*O(SIZE) = O(SIZE) 12
© Keren Kalif

13. מציאת האינדקס המכיל את הערך המקסימלי
public static void main(String[] args) { Scanner s = new Scanner(System.in); int[ ] arr = new int[4]; System.out.printf("Please enter %d numbers: ", arr.length); for (int i=0 ; i < arr.length ; i++) arr[i] = s.nextInt(); int maxIndex = 0; for ( ; ; ) { if (arr[i] > arr[maxIndex]) maxIndex = i; } System.out.printf("The max is at index %d and its value is %d\n“, maxIndex, arr[maxIndex]); 13 11 17 15
int[]:arr
int: i 3
int: maxIndex 2
int[]:arr
int: i 4
int: maxIndex 2
int[]:arr
int: i 2
int: maxIndex
int[]:arr
int: i 1
int: maxIndex
int[]:arr
int: i 2
int: maxIndex
int[]:arr
int: i
???
int: maxIndex
int i=1
i < arr.length
i++ 13
© Keren Kalif

14. הגדרת מערך ניתן להגדיר מערך ב- 2 הדרכים הבאות: int[] arr1, arr2;
int arr3[], x;
// both arr1 and arr2 are arrays
// arr3 is array, x is just int 14
© Keren Kalif

15. אתחול מערך כאשר מקצים מערך ערכי איבריו הוא 0
ניתן לאתחל את איברי המערך במקום הקצאה באחד מן האופנים הבאים:
int arr[] = {5, 3, 1};
int[] arr = {5, 3, 1};
נשים לב כי רק בעת האיתחול ניתן לתת ערך לכמה איברים יחד! כל נתינת ערך בהמשך הינה השמה, ולא איתחול, ולכן יבוצע על כל איבר בנפרד.
//arr[0]=5, arr[1]=3, arr[2]=1
//arr[0]=5, arr[1]=3, arr[2]=1 15
© Keren Kalif

16. אתחול מערך: הגדרת הגודל והערכים
עבור המערכים הבאים:
int[ ] numbers = {5, 3, 1};
char[ ] letters = {‘m’, ‘A’, ‘k’};
הזכרון יראה כך: 5 3 1
int[]: numbers
char[]: letters
‘m’
‘A’
‘k’ 16
© Keren Kalif

17. דוגמא: הדפסת היסטוגרמה של ערכי המערך
דוגמא: הדפסת היסטוגרמה של ערכי המערך
public static void main(String[] args) { int[] arr = {4, 3, 2, 7}; System.out.printf("There are %d numbers in the array: \n", arr.length); for (int i=0 ; i < arr.length ; i++) { System.out.print(arr[i] + “: “); for (int j=0 ; j < arr[i] ; j++) System.out.print("*"); System.out.println(); } 17
© Keren Kalif

18. הגדרה: מערך סימטרי (פלינדרום)
מערך שאם נקרא את ערכיו משמאל לימין או ההפך נקבל אותו הדבר 18
© Keren Kalif

19. דוגמא: האם איברי המערך סימטריים
public static void main(String[] args) { Scanner s = new Scanner(System.in); int arr[] = new int [5], left, right; boolean isSymetric=true; System.out.printf("Enter %d numbers: ", arr.length); for (int i=0 ; i < arr.length ; i++) arr[i] = s.nextInt(); for (left=0, right=arr.length-1; left < right && isSymetric ; left++, right--) { if (arr[left] != arr[right]) isSymetric = false; } if (isSymetric) System.out.println("The array is symetric"); else System.out.println("The array is NOT symetric");
left
right 1 2 3 4 8 5 7 1 2 3 4 8 5
isSymetric = true
isSymetric = false 19
© Keren Kalif

20. שגיאה נפוצה left right isSymetric = true isSymetric = false 8 7 9 1 2
public static void main(String[] args) { Scanner s = new Scanner(System.in); int arr[] = new int [5], left, right; boolean isSymetric=true; System.out.printf("Enter %d numbers: ", arr.length); for (int i=0 ; i < arr.length ; i++) arr[i] = s.nextInt(); for (left=0, right=arr.length-1; left < right && isSymetric ; left++, right--) { if (arr[left] != arr[right]) isSymetric = false; else isSymetric = true; } if (isSymetric) System.out.println("The array is symetric"); System.out.println("The array is NOT symetric");
שגיאה נפוצה
left
right 1 2 3 4 8 7 9
isSymetric = true
isSymetric = false 20
© Keren Kalif

21. דוגמא: היום המועדף בשבוע - פלט
בהמשך נראה מה היה קורה אם המשתמש היה מכניס ערך שאינו בין 1 ל-7! 21
© Keren Kalif

22. דוגמא: היום המועדף בשבוע
public static void main(String[] args) { Scanner s = new Scanner(System.in); final int EXIT = -1; int daysFrequency[] = new int[7], day, maxDayIndex; do { System.out.printf("Insert the day you like most (1-7), %d to EXIT: ", EXIT); day = s.nextInt(); if (day != EXIT) daysFrequency[day-1]++; } while (day != EXIT); System.out.println("Each day and number of persons who liked it most:"); for (int i=1 ; i<=7 ; i++) System.out.printf("%d: %d\n", i, daysFrequency[i-1]); maxDayIndex = 0; for (int i=1 ; i < 7 ; i++) { if (daysFrequency[i] > daysFrequency[maxDayIndex]) maxDayIndex = i; } System.out.println("The favorite day is: “ + (maxDayIndex+1)); 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6
int: i ??
int[]: daysFreq
int: day
int: maxDayIndex ?? -1 ?? 4 ?? 7 ?? 4 ?? -1 22
© Keren Kalif

23. חריגה מגבולות המערך
כדי לגשת לאחד מאיברי מערך בגודל N ניגש עם אינדקסים N
כאשר ננסה לפנות לאינדקס שאינו בגבולות המערך אנו למעשה מנסים לגשת בתא בזיכרון שאיננו יודעים מה יש בו ומה השפעתו, וזוהי גישה לא חוקית לשטח בזיכרון
int[] arr = new int[3];
arr[5] = 7; 23
© Keren Kalif

24. חריגה מגבולות המערך (2) אחריות המתכנת לפנות לתא שבגבולות המערך
הקומפיילר אינו מתריע על ניסיון פניה לתא שאינו בגבולות המערך (יתכן שבזמן קומפילציה אינו ידוע מהו התא אליו מנסים לגשת)
int[] arr = new int[4];
int i;
i = s.nextInt();
arr[i] = 7;
במקרה של חריגה מגבולות המערך התוכנית תעוף עם חריגה IndexOutOfBoundsException
i יכול להיות בין 0-3 ואז הכל בסדר, או לחילופין מספר שלילי או גדול מ- 3 ואז אנו חורגים מגבולות המערך... ש 24
© Keren Kalif

25. השמת מערכים כדי לבצע השמה בין משתנים מאותו הסוג אנו משתמשים באופרטור =
כדי לבצע השמה בין משתנים מאותו הסוג אנו משתמשים באופרטור =
int x, y=5;
x = y;
עבור מערכים השמה תשנה את ההפניה:
int[] arr1={1,2,3}, arr2 = new int[3];
arr2 = arr1;
העתקת ערכי המערכים תבוצע בעזרת לולאה, בה נעתיק איבר-איבר 1 2 3
int[]: arr1
int[]: arr2 25
© Keren Kalif

26. השמת ערכי מערכים - דוגמא
public static void main(String[] args) { int[] arr1 = {1,2,3}, arr2 = new int[3]; // arr2 = arr1; // DOESN'T do what we want!! System.out.print("Elements in arr2 before: "); for (int i=0 ; i < arr2.length ; i++) System.out.printf("%d ", arr2[i]); for (int i=0 ; i < arr2.length ; i++) arr2[i] = arr1[i]; System.out.print("\nElements in arr2 after: "); System.out.println(); } 26
© Keren Kalif

27. דוגמא: קבל מספר והחזר מהי הספרה המופיעה הכי הרבה פעמים
למשל, עבור המספר 12,327,293 תוצג הספרה 2 כי היא מופיעה הכי הרבה פעמים במספר (3 פעמים)
אופציה 1: לספור באמצעות לולאה כמה פעמים בכל המספר מופיעה הספרה 1, כנ"ל עבור הספרה 2 וכו'
10*O(n), כאשר n הוא מספר הספרות במספר
10*O(n) = O(n)
אופציה 2: מיון דליים
O(n), כאשר n הוא מספר הספרות במספר 27
© Keren Kalif

28. הקוד O(n) O(n) public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int num, counters[] = new int[10];
System.out.print(“Enter number :”);
num = s.nextInt();
while (num > 0) {
counters[num % 10]++;
num /= 10; }
int max = 0;
for (i = 1; i < 10; i++)
if (counters[i] > counters[max])
max = i;
System.out.println(“The digit that
appears most is “ + max);
O(n)
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int num, maxDigit=0, maxCount=0;
System.out.println(“Enter number :”);
num = s.nextInt();
for (int i = 0; i < 10; i++) {
int temp = num;
int count = 0;
while (temp > 0) {
if (temp % 10 == i)
count++;
temp /= 10; }
if (count > maxCount) {
maxCount = count;
maxDigit = i;
System.out.println(“The digit that appears most is “ + maxDigit);
O(n) 28
© Keren Kalif

29. דוגמא
הגדר מערך של 10 תווים, קלוט לתוכו נתונים מהמקלדת, והדפס למסך את התווים שהוקלדו ללא חזרות, וכן את כמות התווים השונים
דוגמא: אם המשתמש הכניס את התווים הבאים:
a 0 ? T T 0 $ a T x
אזי התכנית תודיע שיש 6 תווים שונים ותדפיס למסך:
a 0 ? T $ x 29
© Keren Kalif

30. אסטרטגיית הפתרון המשתנים בהם נשתמש: האלגוריתם:
counter: תפקידו לספור את כמות התווים השונים
hasAppear: דגל שתפקידו לדעת האם תו כבר הופיע בתווים שלפניו
האלגוריתם:
אפס counter
עבור כל תו במערך:
אפס דגל
עבור כל אחד מהתווים שלפניו במערך וכל עוד הדגל לא סומן:
אם התו הנבדק והתו הנוכחי זהים:
סמן את הדגל (כדי להפסיק את לולאת בדיקת התווים שלפניו)
אם הדגל נשאר כבוי, הדפס את התו למסך והגדל את ה- counter 30
© Keren Kalif

31. קוד הפתרון קליטת הנתונים איפוס הדגל עבור התו הנוכחי
public static void main(String[] args) { Scanner s = new Scanner(System.in); int count=0; boolean hasAppear = false; char[] str = new char[10]; System.out.printf("Please enter %d chars: “, str.length); for (int i=0 ; i < str.length ; i++) str[i] = s.next().charAt(0); // print each char only once System.out.println("The chars are:”); for (int i=0 ; i < str.length ; i++) } hasAppear = false; for (int j=0 ; j < i && !hasAppear; j++) { if (str[i] == str[j]) hasAppear = true; } if (!hasAppear) } System.out.print(str[i]); count++; { System.out.printf("\nThere were %d different letters\n”, count);
קוד הפתרון
קליטת הנתונים
איפוס הדגל עבור התו הנוכחי
אם התו זהה לאחד התווים שלפניו, נדליק את הדגל
אם התו לא הופיע, נדפיס אותו ונגדיל את ה- counter 31
© Keren Kalif

32. מערך דו-מימדי - מוטיבציה
כדי לשמור ציונים של 30 סטודנטים בכיתה נגדיר מערך בגודל 30:
int[] grades = new int[30];
אם יש לנו 3 כיתות שעבורן נרצה לשמור ציונים של 30 סטודנטים בכיתה נצטרך להגדיר 3 מערכים:
int[] grades1=new int[30], grades2=new int[30], grades3=new int[30];
אבל 3 הכיתות האלו הן גם אוסף של משתנים מאותו הסוג – מערך של מספרים בגודל 30
לכן נרצה להגדיר מערך שיש בו 3 איברים, וכל איבר הוא מערך בגודל 30:
int[][] grades = new int[3][30]; 32
© Keren Kalif

33. מערך דו-מימדי
בהגדרת מערך חד-מימדי מגדירים את מספרהתאים בו (מספר העמודות):
int[] arr = new int[4];
בהגדרת מערך דו-מימדי נגדיר את מספר התאים בו ע"י ציון מספר השורות ומספר העמודות:
int[][] arr = new int[2][4];
מערך דו-מימדי הוא למעשה מטריצה, או ניתן להסתכל עליו כמערך של מערכים
arr[0]
arr[1]
arr[2]
arr[3]
arr [0][0]
arr [0][1]
arr [0][2]
arr [0][3]
arr [1][0]
arr [1][1]
arr [1][2]
arr [1][3] 33
© Keren Kalif

34. הגדרת מערך דו-מימדי כדי להגדיר מערך חד-מימדי הגדרנו למשל:
double[] numbers = new double[4];
ובאופן כללי:
type[] <name> = new type[SIZE];
כדי להגדיר מערך דו-מימדי נגדיר למשל:
double[][] numbers = new double[2][4];
type[][] <name> = new type[ROWS][COLS]; 34
© Keren Kalif

35. מערך דו-מימדי - פניה לאיבר
מערך דו-מימדי - פניה לאיבר
int[][] arr = new int[2][4];
כדי לפנות לאיבר במערך דו-מימדי צריך לציין את מספר השורה ואת מספר העמודה של האיבר אשר איתו אנו רוצים לעבוד
למשל, כדי לשנות את ערכו של האיבר בשורה השנייה בעמודה השלישית:
arr[1][2] = 5;
למשל, כדי לשנות את ערכו של האיבר בשורה הראשונה בעמודה הראשונה:
arr[0][0] = 5;
arr [0][0]
arr [0][1]
arr [0][2]
arr [0][3]
arr [1][0]
arr [1][1]
arr [1][2]
arr [1][3]
arr [0][0]
arr [0][1]
arr [0][2]
arr [0][3]
arr [1][0]
arr [1][1]
arr [1][2]
arr [1][3]
arr [0][0]
arr [0][1]
arr [0][2]
arr [0][3]
arr [1][0]
arr [1][1]
arr [1][2]
arr [1][3] 35
© Keren Kalif

36. מערך דו-מימדי - מספר האיברים
מערך דו-מימדי - מספר האיברים
int[][] arr = new int[2][4];
כדי לדעת כמה שורות יש: arr.length
כדי לדעת כמה איברים יש בשורה: arr[0].length
arr [0][0]
arr [0][1]
arr [0][2]
arr [0][3]
arr [1][0]
arr [1][1]
arr [1][2]
arr [1][3]
arr [0][0]
arr [0][1]
arr [0][2]
arr [0][3]
arr [1][0]
arr [1][1]
arr [1][2]
arr [1][3]
arr [0][0]
arr [0][1]
arr [0][2]
arr [0][3]
arr [1][0]
arr [1][1]
arr [1][2]
arr [1][3] 36
© Keren Kalif

37. מערך דו-מימדי – דוגמא: קליטת ציונים לכמה כיתות והדפסתם - פלט37
© Keren Kalif

38. מערך דו-מימדי – דוגמא: קליטת ציונים לכמה כיתות והדפסתם
public static void main(String[] args) { Scanner s = new Scanner(System.in); final int NUM_CLASSES=3, STUDENTS_IN_CLASS=5; int [][] grades = new int[NUM_CLASSES][STUDENTS_IN_CLASS]; System.out.printf("Please enter grades for students in %d classes:\n", grades.length); for (int i=0 ; i < grades.length ; i++) { System.out.printf("Please enter grades for %d students in class #%d:", grades[0].length, i+1); for (int j=0 ; j < grades[i].length ; j++) grades[i][j] = s.nextInt(); } System.out.println("The grades in all classes:"); System.out.printf("Class #%d: ", i+1); System.out.print(grades[i][j] + “ “); System.out.println(); 38
© Keren Kalif

39. מערך דו-מימדי – דוגמא: קליטת ציונים לכמה כיתות והדפסת הממוצע - פלט39
© Keren Kalif

40. מערך דו-מימדי – דוגמא: קליטת ציונים לכמה כיתות והדפסת הממוצע
public static void main(String[] args) { Scanner s = new Scanner(System.in); final int NUM_CLASSES=3, STUDENTS_IN_CLASS=5; int [][] grades = new int[NUM_CLASSES][STUDENTS_IN_CLASS]; float[] average = new float[NUM_CLASSES]; System.out.printf("Please enter grades for students in %d classes:\n", grades.length); for (int i=0 ; i < grades.length ; i++) { System.out.printf("Please enter grades for %d students in class #%d:", grades[i].length, i+1); int sum=0; for (int j=0 ; j < grades[i].length ; j++) { grades[i][j] = s.nextInt(); sum += grades[i][j]; } average[i] = (float)sum/STUDENTS_IN_CLASS; System.out.println("The average for each classe:"); for (int i=0 ; i < average.length ; i++) System.out.printf("Average for class #%d: %f\n", i+1, average[i]); 40
© Keren Kalif

41. מערך דו-מימדי – ייצוגו בזיכרון
מערך דו-מימדי נשמר בזכרון כמערך של מערכים:
int [][] arr = new arr[2][3];
int[][]: arr
arr[0][0]
arr[0][1]
arr[0][2]
arr[1][0]
arr[1][1]
arr[1][2] 41
© Keren Kalif

42. מערך דו-מימדי - איתחול ניתן לאתחל מערך דו-מימדי באופן הבא:
int [][] numbers = { {1,2,3}, {4,5,6}};
System.out.println(numbers.length); //  2
System.out.println(numbers[0].length); //  3
ומכאן ניתן לראות כי ניתן לייצר מערך של מערכים שאורכי שורותיו שונים!
int[][]: numbers 4 5 6 1 2 3 42
© Keren Kalif

43. מערך דו-מימדי מאותחל בשורות באורך שונה
int [][] numbers = { {1,2,3}, {4,5,6,7}}; System.out.println(numbers.length); //  2 System.out.println(numbers[0].length); //  3 System.out.println(numbers[1].length); //  4
int[][]: numbers 4 5 6 7 1 2 3
מערך דו-מימדי שאורכי שורותיו שווים נקרא מטריצה מלבנית
מערך דו-מימדי שאורכי שורותיו שונים נקרא מטריצה jagged 43
© Keren Kalif

44. מערך דו-מימדי מוקצה בשורות באורך שונה
int: lines 2
int: cols
int[][]: numbers
int: lines 2
int: cols 3
int[][]: numbers
int: lines
int: cols
int[][]: numbers
int: lines 2
int: cols 4
int[][]: numbers
public static void main(String[] args) { Scanner s = new Scanner(System.in); System.out.print("How many lines? "); int lines = s.nextInt(); int [][] numbers = new int[lines][]; for (int i=0 ; i < numbers.length ; i++) { System.out.print("How many elements int line # " + (i+1) + "? "); int cols = s.nextInt(); numbers[i] = new int[cols]; } 44
© Keren Kalif

45. מערך דו-מימדי – דוגמא: מציאת סכום איברי האלכסון של מטריצה ריבועית
public static void main(String[] args) { int[][] matrix = { {1,1,1,1}, {2,4,4,2}, {3,2,1,0}, {7,6,5,4} }; int sum=0; //System.out.println("The matrix is:"); //for (int i=0 ; i < matrix.length ; i++) { // for (int j=0 ; j < matrix[i].length ; j++) // System.out.printf("%d\t", matrix[i][j]); // System.out.println(); //} // calc the sum of the main diagonal for (int i=0 ; i < matrix.length ; i++) for (int j=0 ; j < matrix[i].length ; j++) if (i == j) sum += matrix[i][j]; System.out.println("The sum of the main diagonal is “ + sum); }
ניתוח זמן הריצה של תוכנית זו (ללא לולאת הפלט):
O(main) = O(1) + SIZE*O(SIZE) = O(SIZE2) 45
© Keren Kalif

46. מערך דו-מימדי – דוגמא: מציאת סכום איברי האלכסון של מטריצה ריבועית (2)
מערך דו-מימדי – דוגמא: מציאת סכום איברי האלכסון של מטריצה ריבועית (2)
public static void main(String[] args) {
int[][] matrix = { {1,1,1,1}, {2,4,4,2}, {3,2,1,0}, {7,6,5,4} };
int sum=0;
//System.out.println("The matrix is:");
//for (int i=0 ; i < matrix.length ; i++) {
// for (int j=0 ; j < matrix[i].length ; j++)
// System.out.printf("%d\t", matrix[i][j]);
// System.out.println();
//}
// calc the sum of the main diagonal
for (int i=0 ; i < matrix.length ; i++)
sum += matrix[i][i];
System.out.println("The sum of the main diagonal is “ + sum); }
ניתוח זמן הריצה של תוכנית זו (ללא לולאת הפלט):
O(main) = O(1) + O(SIZE) = O(SIZE)
2 הדוגמאות פותרות בדרך שונה את אותה הבעיה,
אבל בסיבוכיות שונה. לכן נעדיף פתרון זה אשר
הסיבוכיות שלו קטנה בסדר גודל שלם מהפתרון הקודם! 46
© Keren Kalif

47. מערך דו-מימדי – דוגמא: הדפסת הסכום של כל עמודה
public static void main(String[] args) { int[][] matrix = { {1,1,1,1}, {2,4,4,2}, {7,6,5,4} }; System.out.println("The matrix is:"); for (int i=0 ; i < matrix.length ; i++) { for (int j=0 ; j < matrix[i].length ; j++) System.out.printf("%d\t", matrix[i][j]); System.out.println(); } for (int i=0 ; i < matrix[0].length ; i++) { int sum=0; for (int j=0 ; j < matrix.length ; j++) sum += matrix[j][i]; System.out.printf("The sum of elements in column #%d %d\n", i+1, sum);
ניתוח זמן הריצה של תוכנית זו:
O(main) =
O(1) + ROWS*O(COLS) + COLS*O(ROWS) =
O(ROWS*COLS) 47
© Keren Kalif

48. מערך דו-מימדי – דוגמא: הכנסת מספרים למטריצה בצורת נחש
public static void main(String[] args) {
int[][] matrix = new int[8][5];
int value = 1;
for (int i=0 ; i < matrix.length ; i++) }
if (i%2 == 0)
for (int j=0 ; j < matrix[i].length; j++)
matrix[i][j] = value++;
else
for (int j= matrix[i].length -1 ; j >= 0 ; j--) {
// print matrix
for (int i=0 ; i < matrix.length; i++) }
for (int j=0 ; j < matrix[i].length ; j++)
System.out.printf("%4d", matrix[i][j]);
System.out.println(); 48
© Keren Kalif

49. מערך רב-מימדי עד כה ראינו מערכים חד-מימדיים ומערכים דו-מימדיים
ניתן להרחיב את ההגדרה לכל מספר סופי של מימדים
למשל: מערך תלת –מימדי
int[][][] matrix = new int[LENGTH][HEIGHT][DEPTH];
דוגמא לשימוש: נרצה לשמור ממוצע ציונים עבור 5 בתי-ספר, כאשר בכל בית-ספר יש 10 כיתות, ובכל כיתה 30 סטודנטים:
double[][][] average = new int[5][10][30];
במקרה זה נשתמש בלולאה, בתוך לולאה, בתוך לולאה.. 49
© Keren Kalif

50. מערך רב-מימדי – דוגמאת נתוני בתי- הספר50
© Keren Kalif
מערך רב-מימדי – דוגמאת נתוני בתי- הספר
public static void main(String[] args) { float[][][] grades = { { {90, 100, 95, 88}, {87, 70, 90, 98} }, { {88, 75, 80, 60}, {55, 87, 90, 82} }, { {60, 91, 40, 95}, {77, 66, 88, 99} } }; for (int i=0 ; i < grades.length; i++) { System.out.printf("Classes in school #%d:\n", i+1); for (int j=0 ; j < grades[i].length; j++) { System.out.printf(" Grades in class #%d: ", j+1); for (int k=0 ; k < grades[i][j].length; k++) System.out.printf("%.2f ", grades[i][j][k]); System.out.println(); }

51. לולאת for-each
ראינו שניתן לעבור על ערכי המערך בלולאה באמצעות פנייה לתוכן שבאינדקס מסויים:
for (int i=0 ; i < arr.length ; i++)
System.out.print(arr[i] + “ “);
ניתן לעבור על איברי המערך ללא אינדקס: 51
© Keren Kalif

52. ביחידה זו למדנו: מהו מערך כיצד מערך נראה בזיכרון גישה לאיברי המערך
אתחול מערך
חריגה מגבולות המערך
השמת מערכים
מערך דו-מימדי
מערך רב-מימדי
לולאת for-each 52
© Keren Kalif

53. תרגילי חימום:
הגדר מערך בגודל 10 של מספרים שלמים וקלוט לתוכו ערכים. הצג רק ערכים שהם זוגיים.
הגדר מערך בגודל 10 של תווים וקלוט לתוכו ערכים. הצג את האינדקסים שבתוכם ישנו תו שהוא אות גדולה.
הגדר מערך של מספרים בגודל 10 ושים בתוכו לפי הסדר ערכים שהם כפולות של 3: כלומר הערכים 0, 3, 6 וכו'.
הגדר מערך של מספרים שלמים וקלוט לתוכו ערכים. הגדל ב- 1 את הערכים שנמצאים במיקומיים זוגיים (0, 2, 4 וכו').
הגדר מערך של מספרים שלמים בגודל 10 וקלוט לתוכו ערכים. הגדל ב- 1 את הערכים שנמצאים במיקומיים זוגיים (0, 2, 4 וכו') ואח"כ הקטן ב-1 את הערכים שנמצאים במיקומים שהם כפולה של 3 (0, 3, 6 וכו'). 53
© Keren Kalif

54. תרגילי חימום:
הגדר מערך של תווים וקלוט לתוכו ערכים, וכן קלוט תו נוסף. הצג כמה פעמים התו הנוסף שהתקבל מופיע במערך.
 הגדר שני מערכים של מספרים שלמים בגודל 5 כל אחד. קלוט ערכים לתוך המערך הראשון ואז קלוט ערכים לתוך המערך השני. הצג את המיקומים אשר הערכים בהם בשני המערכים זהים.
 הגדר 3 מערכים של מספרים שלמים בגודל 5 כל אחד. קלוט ערכים לתוך המערכים הראשון והשני. שים בכל איבר במערך השלישי את סכום האיברים במיקומים התואמים במערכים הראשון והשני.
 הגדר מערך של 5 תווים וקלוט לתוכו ערכים. בדוק האם כל התווים שהוקלדו למערך זהים והציגו הודעה מתאימה.
 הגדר מערך של 5 מספרים שלמים וקלוט לתוכו ערכים. בדוק האם ערך כל איבר גדול מערך האיבר שלפניו והצג בסוף הודעה מתאימה. 54
© Keren Kalif

55. תרגיל 1: כתוב תוכנית המגדירה מערך בגודל 10 של מספרים שלמים
כתוב תוכנית המגדירה מערך בגודל 10 של מספרים שלמים
קלוט ערכים מהמשתמש, והדפס את האינדקסים של האיברים שערכם שווה לערך המינימלי במערך
כמו כן יש להדפיס את מספר האינדקסים שבתוכם יש ערך השווה לערך המינימלי
דוגמא:
עבור המערך
יש להדפיס (כי 5 הוא המינימלי והוא נמצא באינדקסים אלו)
וכן להדפיס את הערך 3, מאחר והערך המינימלי מופיע 3 פעמים. 1 2 3 4 5 6 7 8 9 14 12 55
© Keren Kalif

56. תרגיל 2: כתוב תוכנית והגדר בה מטריצה ריבועית של תווים בגודל SIZE
יש לשים את התו '*' על איברי האלכסון הראשי והמשני ורווח בשאר האיברים (לדמות את הצורה X)
הדפס את המטריצה
למשל, עבור SIZE=5 המטריצה תראה כך: * 56
© Keren Kalif

57. תרגיל 3: כתוב תוכנית והגדר בה מטריצה בגודל ROWSxCOLS של מספרים
קלוט לתוכה ערכים מהמקלדת
קלוט מהמשתמש מספר והדפס את האינדקס של העמודה בה המספר שהוקלד מופיע הכי הרבה פעמים
אם התו כלל לא מופיע במטריצה יש לתת הודעה מתאימה
שימו לב: אין לעבור על המטריצה בהתחלה כדי לבדוק זאת!
למשל, עבור המטריצה הבאה והמספר 3 יוצג 2 כי המספר 3 מופיע הכי הרבה פעמים בעמודה 2 1 9 3 8 2 5 7 6 4 57
© Keren Kalif