1. יסודות מדעי המחשב – תרגול 3
מערכים, מחרוזות ומיונים

2. מהלך התרגול שימושים למערכים (מטריצות) ייצוג char מחרוזות מיון מחרוזות
משחקי מצביעים

3. הכפלת וקטורים = ∑v(1,j)*u(j,1) X
הכפלת וקטורים בצורה הנ"ל יתן כתוצאה סקלר (מספר) שהינו סכום מכפלות התאים:
v(1,1)*u(1,1) + v(1,2)*u(2,1) + v(1,3)*u(3,1)

4. הכפלת וקטורים
/**
* This method calculate vector multiplication ([1xM]*[Mx1])
vector1- An 1xM double array holds the multiplicand vector.
vector2- An Mx1 double array holds the multiplier vector.
res- A double scalar holds the vector product result. */
public static double VectorMult( double[] vector1, double[] vector2) {
int M=vector1.length;
double res=0;
for (int m=0;m< M;m++) //run in loop on vector values
res +=vector1[m]*vector2[m]; }
return res;

5. הכפלת מטריצה בוקטור = ∑v(1,j)*u(j,1) ∑v(2,j)*u(j,1) ∑v(3,j)*u(j,1) X
A(1,3)
A(1,2)
A(1,1)
A(2,3)
A(2,2)
A(2,1)
A(3,3)
A(3,2)
A(3,1)
u(1,1)
u(2,1)
u(3,1)
c(1,1)
c(2,1)
c(3,1)
∑v(1,j)*u(j,1) =
∑v(2,j)*u(j,1) X
∑v(3,j)*u(j,1)
הכפלת מטריצה בוקטור בצורה הנ"ל יתן כתוצאה וקטור שבו כל תא הינו סכום מכפלות התאים:
c(1,1) = A(1,1)*u(1,1) + A(1,2)*u(2,1) + A(1,3)*u(3,1)
c(2,1) = A(2,1)*u(1,1) + A(2,2)*u(2,1) + A(2,3)*u(3,1)
c(3,1) = A(3,1)*u(1,1) + A(3,2)*u(2,1) + A(3,3)*u(3,1)

6. הכפלת מטריצה בוקטור
/** * This method calculate matrix by vector multiplication ([NxM]*[Mx1]) matrix- An NxM double array holds the multiplicand matrix vector- An Mx1 double array holds the multiplier vector resVector- The Nx1 double array holds the product result. */ public static double[] MatrixVectorMult( double[][] matrix,double[] vector) { int N= matrix.length; //matrix number of rows int M= matrix[0].length; //matrix number of column double[] resVector= new double[N]; for (int n=0;n< N;n++)// run in loop on matrix rows resVector[n] =VectorMult(matrix[n],vector); } return resVector;

7. שחלוף מטריצה A(i,j)  A(j,i) Transpose
בשחלוף מטריצה, מתבצעת החלפת הערכים בתאי השורות והעמודות כמתואר לעיל

8. שחלוף מטריצה (Transpose)
/** * This method calculate matrix transpose matrix- An NxM double array holds the matrix to be transpose. matrixTranspose- An MxN double array holds matrix transpose. */ private static double[][] MatrixTranspose(double[][] matrix) { double[][] matrixTranspose; int N=matrix.length; int M=matrix[0].length; matrixTranspose= new double[M][N]; for (int n=0;n< N;n++) for(int m=0;m< M;m++) matrixTranspose[m][n]=matrix[n][m]; } return matrixTranspose;

9. הכפלת מטריצות ∑a(1,j)*b(j,1) ∑a(2,j)*b(j,3) ∑a(3,j)*b(j,2) X =
c(1,3)
c(1,2)
c(1,1)
c(2,3)
c(2,2)
c(2,1)
c(3,3)
c(3,2)
c(3,1)
b(1,3)
b(1,2)
b(1,1)
b(2,3)
b(2,2)
b(2,1) X =
∑a(2,j)*b(j,3)
∑a(3,j)*b(j,2)
הכפלת מטריצת NxM במטריצת MxN יתן כתוצאה מטריצת NxN שכל תא בא הוא מכפלת הוקטור שורה ה-i במטריצה הראשונה בוקטור עמודה ה-j במטריצה הראשונה:
c(i,j) = ∑a(i,k)*b(k,j) (עבור כל ערכי ה-k האפשריים במטריצה)

10. הכפלת מטריצות
/** * This method calculate matrix multiplication ([NxM]*[MxN]) matrix1- An NxM double array holds the multiplicand matrix matrix2- An MxN double array holds the transpose of the multiplier matrix resMat- The NxN double array holds the product result. */ public static double[][] MatrixMult(double[][] matrix1,double[][] matrix2) { int N=matrix1.length; //multilicand matrix number of rows matrix2=MatrixTranspose(matrix2); double[][] resMat=new double[N][]; for (int i=0;i< N;i++) //run in loop on matrix rows resMat[i]=MatrixVectorMult(matrix1,matrix2[i]); } resMat=MatrixTranspose(resMat); return resMat;

11. ייצוג char
char char1 = ‘b’; char char2 = ‘a’; System.out.print(char1); -> System.out.print ((int) char2); -> System.out.print ((int) char1); -> System.out.print ((char)97); -> System.out.print ((char)(int)char1); -> int i = ‘1’; // i=49 System.out.print (i+1); -> char c = ‘9’; // c=57 System.out.print (c-’0’); -> char A = 65; System.out.print (A); -> A<B<..<Z<a<b<..<z b 97 98 a 50 9 A

12. מחרוזות (Strings)
מחרוזת (String) הינה משתנה מורכב היכול להכיל רצף של תווים.
המשתנה מתנהג כמו משתנה מערך בכך שלמעשה מצביע על המחרוזת ששמורה במקום כלשהו בזיכרון.
בשונה ממערך, לא ניתן לגשת ישירות למחרוזת ולשנות את התווים האינדיווידואלים.
ניתן לאתחל בשתי צורות:
String str1 = new String(“Hello “);
String str2 = “World”;
ניתן לבצע פעולת חיבור בין מחרוזות: String str3 = str1+str2
בנוסף, קיימות פונקציות שונות שניתן להפעיל מתוך המחרוזת כגון:
str1.charAt(4)
str2.length()
str3.indexOf(‘l’)

13. מיון מחרוזות שימו לב – המחלקה Sort נמצאת בחומר עזר באתר
public class sortExample { /** args */ public static void main(String[] args) { String[] strArr = {"g","r","a","e","hello","world","bungee","alligator","java","gray","bun","t", "c","grab"}; char[] charArr = {'g','c','e','a','r','s','z','l'}; System.out.println("printing string array"); printArray(strArr); Sort.strLengthSort(strArr); System.out.println("printing length sorted array"); Sort.stringSort(strArr); System.out.println("printing lexicographicly sorted array"); System.out.println("printing character array"); printArray(charArr); Sort.charSort(charArr); System.out.println("printing sorted character array"); }
public static void printArray(String[] arr) {
int i;
for (i=0;i<arr.length;i++)
System.out.println(arr[i]); }
public static void printArray(char[] arr)
System.out.print(arr[i]);
System.out.print(".");
System.out.println();
שימו לב – המחלקה Sort נמצאת בחומר עזר באתר