מבוא לתכנות ב- JAVA תרגול 8

תמליל

1 מבוא לתכנות ב- JAVA תרגול 9

2 מה בתרגול דוגמאות מתקדמות ברקורסיה פרמוטציות N מלכות מיונים רקורסיביים מיון מיזוג מיון מהיר

3 הדפסת פרמוטציות של מחרוזת פרמוטציה של מחרוזת מוגדרת כמחרוזת המכילה את אותן אותיות, ייתכן שבשינוי סדר. נניח בדוגמה זו שכל האותיות שונות זו מזו. למשל הפרמוטציות עבור המחרוזת bcd הן: bcd" bdc" cbd cdb dbc dcb

4 הרעיון של הרקורסיה d, a + b + c, a + b + c + d output: abcd cd, a + b bcd, a abcd, 4

5 הרעיון של הרקורסיה d, a + b + c cd, a + b, a + b + c + d output: abcd, a + b + d + c bcd, a c, a + b + d output: abdc abcd, 5

6 הרעיון של הרקורסיה d, a + b + c cd, a + b, a + b + c + d output: abcd, a + b + d + c bcd, a c, a + b + d output: abdc abcd, bd, a + c d, a + c + b output: acbd, a + c + b + d 6

7 הרעיון של הרקורסיה d, a + b + c cd, a + b, a + b + c + d output: abcd, a + b + d + c bcd, a c, a + b + d output: abdc abcd, bd, a + c... bc, a + d d, a + c + b output: acbd..., a + c + b + d 7

8 קוד הדפסת הפרמוטציות של מחרוזת /** Function prints all the permutations of a string. * Note: assume the string is a set (no duplicate * chars) */ // Prints string acc followed by all permutations of // string s1 public static void perms(string s, String acc){ if (s.length()==0) System.out.println(acc); else for (int i=0; i<s.length(); i++) perms(s.substring(0,i) + s.substring(i+1), acc + s.charat(i)); 8

9 קוד הדפסת הפרמוטציות של מחרוזת public static void perms(string s){ // We call the method perm(s,"") which prints // the empty string followed by each permutation // of s the empty string. perms(s,""); 9

10 N מלכות יש למקם N מלכות על לוח שחמט בגודל N*N שאף אחת מהמלכות לא מאיימת על אף אחת מחברותיה כך מהלכים אפשריים של מלכה

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

12 הרעיון מה מקרה הבסיס? מה הצעד הרקורסיבי? no

13 - פתרון מלכות N public static boolean solvenqueens(int[][] board, int i) { if (i == board.length){ return true; for(int j=0; j < board.length; j++){ if (issafe(board,i,j)){ board[i][j] = 1; if (solvenqueens(board,i+1)){ return true; else{ board[i][j] = 0; return false;

14 - פתרון מלכות N public static void solvenqueens(int n){ int[][] board = new int[n][n]; if (solvenqueens(board,0)){ printboard(board); else{ System.out.println("no soution");

15 - פתרון מלכות N public static boolean issafe(int[][] board, int i, int j) { //attacked by other in left diagonal for (int r = 1; j-r > -1 && i-r > -1; r++){ if (board[i-r][j-r] == 1){ return false; //attacked by other in right diagonal for (int r = 1; j+r < board.length && i-r > -1; r++){ if (board[i-r][j+r] == 1){ return false; // check if there is another queen in same column for (int r = 0; r < i; r++){ if (board[r][j] == 1){ return false; return true;

16 N מלכות בקריאה לפונקציה solvenqueens(4) הודפס למסך הפתרון הבא איזה מהמשפטים הבאים הוא נכון: א. אין פתרון ללוח 4*4 בפינה השמאלית כך שהמלכה בשורה הראשונה היא ב. האלגוריתם מחזיר רק פתרון אחד מתוך רבים. אם היינו בוחרים למקם אחרת את המלכות באלגוריתם, ייתכן שהיה מחוזר פתרון בו המלכה בשורה הראשונה היא בפינה השמאלית

17 מיון מיזוג אלגוריתם מיון רקורסיבי רעיון: חלק את המערך לשני חלקים מיין כל חלק באופן רקורסיבי מזג את שני החלקים למערך ממויין )בשיטת הפרד ומשול( אחד

18 דוגמא

19 דוגמא

20 דוגמא

21 דוגמא

22 דוגמא Merge 4 0

23 דוגמא Merge

24 דוגמא Merge

25 דוגמא Merge

26 דוגמא

27 איך ממזגים 2 מערכים ממויינים? נניח שאנו רוצים למזג את המערכים הממויינים A,B למערך ממויין C נשתמש ב 2 אינדקסים i,j )אחד לכל מערך( כל עוד i,j לא מצביעים על סיום המערכים: השווה את שני האיברים A[i] ו B[j] את הקטן מבין השניים הכנס למערך המיזוג קדם את האינדקס של האיבר שאנחנו מסתכלים עליו במערך ב- 1. אם אחד מהאינדקסים מצביע על סיום המערך בעוד השני לא נעתיק את כל יתר האיברים מהמערך השני אל C.

28 דוגמא - מיזוג X: Y: Result:

29 דוגמא - מיזוג X: Y: Result: 1

30 דוגמא - מיזוג X: Y: Result: 1 3

31 דוגמא - מיזוג X: Y: Result: 1 3 5

32 דוגמא - מיזוג X: Y: Result:

33 דוגמא - מיזוג X: Y: Result:

34 דוגמא - מיזוג X: Y: Result:

35 דוגמא - מיזוג X: Y: 75 Result:

36 דוגמא - מיזוג X: Y: Result:

37 פונקצית מיון-מיזוג public static void mergesort(int[] arr) { mergesort(arr, 0, arr.length-1); private static void mergesort(int[] arr, int low, int high) { if (low < high) { int middle = (high + low) / 2; mergesort(arr, low, middle); mergesort(arr, middle + 1, high); merge(arr, low, middle, high);

38 פונקצית מיזוג merge private static void merge(int[] arr, int low, int middle, int high) { int i = low; int j = middle+1; int k = 0; int[] mergedarray = new int[high-low+1]; while (i <= middle && j <= high){ if (arr[i] < arr[j]){ mergedarray[k] = arr[i]; i++; else{ mergedarray[k] = arr[j]; j++; k++; for (int l = i ; l <= middle; l++){ mergedarray[k] = arr[l]; k++; for (int l = j ; l <= high; l++){ mergedarray[k] = arr[l]; k++; for (int l = low ; l <= high; l++){ arr[l] = mergedarray[l-low];

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

40 - מיון מהיר )Quicksort( דוגמא

41 פונקציה למיון מהיר public static void quicksort(int[] arr){ quicksort(arr, 0, arr.length-1); public static void quicksort(int[] arr, int start, int end){ if (start<end){ int i = partition(arr, start, end); quicksort(arr, start, i-1); quicksort(arr, i+1, end); 41

42 מימוש פונקציית partition כל שנותר הוא לממש את פונקציית.partition ברצוננו לממש פונקציה אשר מקבלת מערך ומשנה אותו כך שקודם כל יופיעו כל המספרים הקטנים או שווים לציר )האיבר הראשון(, לאחר מכן הציר, ולבסוף המספרים הגדולים מהציר. קלט : פלט: 15 42

43 partition מיון מהיר public static int partition(int[] arr, int start, int end){ int pivot = arr[start]; int i = start; int j = end; while(i<j){ while(i<end && arr[i] <= pivot) //scan upwards i=i+1; while(arr[j] > pivot) //scan downwards j=j-1; if (i<j) swap(arr,i,j); swap(arr,start,j); //put the pivot in place return j; 43