נושאים מחרוזות מיון (מיון בועות) רקורסיה תרגול מס' 4  נושאים מחרוזות מיון (מיון בועות) רקורסיה

מחרוזות הקדמה מחרוזת (String) היא מחלקה המייצגת טקסט (רצף של תווים). מיספור אינדקס התווים במחרוזת מתחיל מ 0 ונגמר באורך המחרוזת פחות 1. String "abcd" Index 0123 2

מחרוזות פעולות על מחרוזות: הגדרה ואתחול String s1; String s2 = "abcd"; String s3 = null; String s4 = ""; String s5 = new String(); 3

מחרוזות String s2 = "abcd"; String s3 = null; String s4 = ""; אורך s2.length() 4 s3.length() NullPointerException s4.length() 0 4

מחרוזות String s2 = "abcd"; תו במיקום (אינדקס) מסוים s2.charAt(0) StringIndexOutOfBoundsException :String index out of range 5

מחרוזות String s2 = "abcd"; תת-מחרוזת החל מאינדקס i ועד אינדקס j (לא כולל את j). s2.substring(1,3) "bc" s2.substring(1) "bcd" השוואה בין תוכן שתי מחרוזות. התוצאה בוליאנית (true או false). s2.equals(s4) שרשור + s2+"efg" יוצר מחרוזת חדשה "abcdefg". המחרוזת s2 לא משתנה. String s2 = "abcd"; 6

מחרוזות דוגמה 1 – מחרוזת עם סדר תווים הפוך לפנינו פונקציה Reverse המקבלת מחרוזת ומחזירה מחרוזת אחרת שבה התווים של Reverse . בסדר (מיקום) הפוך. הפונקציה הראשית מפעילה את Reverse על המחרוזת "Hello" ומדפיסה את התוצאה (olleH). 7

public class StringsReverser { public static String Reverse( String data ) { String rev = new String(); for ( int j= data.length()-1; j>=0; j=j-1 ) rev = rev + data.charAt(j); return rev; } public static void main ( String[] args ) { System.out.println( Reverse( "Hello" ) ); 8

מחרוזות דוגמה 2 – חיפוש של תת-מחרוזת במחרוזת לפנינו פונקציה isSubstring המקבלת שתי מחרוזת str ו- sub ובודקת האם sub מופיעה בתוך str כתת מחרוזת. הפונקציה מחזירה תשובה בוליאנית. למשל, המחרוזת "bc" מופיעה כתת-מחרוזת במחרוזת "abcd" באינדקס 1. String "abcd" Index 0123 נשווה את "bc" לתתי מחרוזות של "abcd" בעלות אורך זהה.

public static boolean isSubstring(String str,String sub){ boolean found = false; int lastInd = str.length()- sub.length(); for ( int i=0; i<=lastInd && ! found ; i=i+1) { String strSub = str.substring(i, i+sub.length()); if (strSub.equals(sub)) found = true; } return found;

מחרוזות דוגמה 3 – צופן קיסר צופן (Cipher) הוא אלגוריתם הצפנה, המקבל טקסט קריא ומפתח - ומחזיר טקסט מוצפן. צופן קיסר מבוסס על רעיון החלפת האותיות של הטקסט הקריא לשם יצירתו של הטקסט המוצפן: האלפבית המשמש להצפנה מוסט מעגלית במספר קבוע של 'מקומות' מן האלפבית הרגיל. המפתח (iKey)= מספר מקומות ההסטה לפי עדויות היסטוריות יוליוס קיסר עשה בשיטה זו שימוש נרחב.

מחרוזות למשל, בהזזת של 3 מקומות המילהBABY תתורגם... למילה EDEB.

public static String encrypt(String str, int key) { String ans = ""; final int NUM_OF_LETTERS_IN_ALPHABET = 26; for(int i = 0; i < str.length(); i=i+1) { int c = str.charAt(i) if ('A'<= c & c <='Z') { c = c - 'A'; c =((c + key) % NUM_OF_LETTERS_IN_ALPHABET)+'A'; } else if ('a'<= c & c <='z'){ c = c - 'a'; c = ((c + key) % NUM_OF_LETTERS_IN_ALPHABET)+'a'; ans = ans + (char) c ; return ans ;

מחרוזות כמה הערות: בפקודה int c = str.charAt(i); מתרחשת המרת טיפוס אוטומאטית מ char ל int. כנ"ל בביטויים כמו 'A'<=c ו- c - 'A'. בפקודה ans = ans + (char) c ; יש המרת טיפוס מפורשת מ int ל char. פעולה זו נחוצה מכיוון שנרצה לשרשר למחרוזת התוצאה ערך char ('A') ולא int (65). הערכים המספריים של כל תו מסוכמים בטבלה (טבלת ASCII, תקן UNICODE). אין כלל צורך לזכור את הטבלה בע"פ.

טבלת ASCII

מחרוזות public static void main(String[] args) { String str = "BEN GURION UNIVERSITY"; int key = 3; String encrypted = encrypt(str, key); System.out.println(encrypted);// "EHQ JXULRQ XQLYHUVLWB" String decrypted = decrypt(encrypted, key); System.out.println(decrypted);// "BEN GURION UNIVERSITY" } שאלה: מהי פעולת פענוח (decrypt) של צופן קיסר? תשובה: בדומה להצפנה, מלבד חיסור של מפתח ההזזה במקום חיבורו.

מחרוזות פריצת צופן קיסר בהינתן טקסט מוצפן כיצד ניתן לגלות את הטקסט הקריא מבלי לדעת את המפתח? ניתן לנחש את המפתח בו הוצפן הטקסט באמצעות סטטיסטיקה על השכיחויות של אותיות האלף בית האנגלי בטקסט כלשהו. האות השכיחה ביותר בטקסט באנגלית היא E, שכיחותה 12%. ניתן לכתוב תוכנית המוצאת את האות השכיחה ביותר בטקסט נתון. סביר להניח שאות זו היא הקידוד של האות E וככה ניתן לחשב בכמה הזזנו את האותיות.

מיונים מיון מערך (array sort) - הגדרת הבעיה: בהינתן מערך A של n מספרים שלמים חשב מערך ממוין של אותם מספרים.   למשל: Input: 7 , 18, 28 , 4, 10 Output: 4, 7, 10 , 18 , 28 ישנם שיטות מיון רבות, כמו: מיון בחירה, מיון הכנסה ומיון בועות.

מיונים מיון בועות (Bubble Sort) תיאור השיטה:   תיאור השיטה: תוך כדי המיון, החלק הימני של המערך כבר ממוין ("מעל פני הים") והחלק השמאלי של המערך אינו ממוין ("מתחת לפני הים"). בכל סבב, "בועה" מבעבעת עד שהיא מגיעה לפני הים. הבועה "סוחבת" איתה ערכים גדולים: בביעבוע הבועה, בכל שני תאים סמוכים בהן עוברת הבועה, מוחלפים הערכים אם הם לא בסדר המיון.

מיונים 18 7 28 4 10 7 18 28 4 10 7 18 4 28 10 7 18 4 10 28 7 4 18 10 28 7 4 10 18 28 7 4 10 18 28 4 7 10 18 28 וכן הלאה עד אשר המערך כולו מעל פני הים.   http://www.youtube.com/watch?v=t_xkgcakREw&feature=related

public static void bubbleSort(int[] array){ int tmp; /. @pre: bbl=0 public static void bubbleSort(int[] array){ int tmp; /* @pre: bbl=0 */ for (int bbl=0; bbl<array.length-1; bbl=bbl+1) { /* @inv: array[array.length- bbl.. array.length-1] is sorted * and all numbers array[array.length-bbl.. array.length-1] * are bigger than the numbers array[0 .. array.length-bbl-1] */ for (int index=0; index < array.length-1; index=index+1) { if (array[index] > array[index+1]) { tmp = array[index]; array[index] = array[index+1]; array[index+1] = tmp; } /* @post: array is sorted */

מיונים שאלה: כמה השוואות מתבצעות? (array[index] > array[index+1]) תשובה: הלולאה הפנימית מבצעת n השוואות. הלולאה החיצונית מתבצעת n פעמים. סה"כ n2 השוואות.   שאלה: האם כל ההשואות נחוצות? תשובה: לא. אם המערך כבר ממוין אין צורך להמשיך בלולאה. (לא צריך לבעבע עוד בועה) השוואות הנעשות בחלק הממויין מיותרות. (פני הים יורדים, ויש להשוות איברים רק מתחת לפני הים)

public static void bubbleSort(int[] array){ boolean isSorted = false; int tmp; for (int bbl=0; !isSorted && bbl<array.length-1; bbl=bbl+1){ isSorted = true; for (int index=0; index<array.length-1-bbl; index=index+1){ if (array[index] > array[index+1]) { tmp = array[index]; array[index] = array[index+1]; array[index+1] = tmp; isSorted = false; }

רקורסיה דוגמה 1: סכום המספרים הטבעיים פונקציה רקורסיבית היא פונקציה שקוראת לעצמה. פונקציה רקורסיבית מחושבת כמו כל פונקציה אחרת (העברת פרמטרים, משתנים לוקאליים, תחום חיים של המשתנים וכו'). מוטיבציה: ישנן בעיות רבות עבורן פתרון רקורסיבי פשוט יותר מפתרון איטרטיבי.   דוגמה 1: סכום המספרים הטבעיים נרצה לחשב את הסכום 1 + 2 + .... + n עבור n נתון.

רקורסיה אפשר בלולאה (פיתרון איטראטיבי): public static int sum(int n) { int ans = 0; for (int i = 1; i <= n; i = i + 1) ans = ans + i; return ans ; }

רקורסיה ואפשר גם בדרך אחרת: נניח שיש לנו פונקציה אחרת בשם magic שמחזירה את הסכום 1 + 2+ ... + (n-1). אז sum יכולה להראות כך: public static int sum(int n) { int ans = magic(n)+ n; return ans ; } אבל magic(n) מחזירה בדיוק מה ש-sum(n-1) הייתה מחזירה.

רקורסיה ניתן להגדיר נוסחה עבור החישוב: sum(n) = sum(n-1)+n … int ans = sum(n-1)+ n;

רקורסיה התוצאה היא פונקציה אחת שתקרא לעצמה: // @pre: n>=1 public static int sum(int n) { int ans; if (n == 1) // stop condition ans = 1; else // recursive call i=1..ni = i=1..(n-1)i + n ans = sum(n - 1) + n; return ans; } // @post: returns i=1..ni *** מעקב על דוגמת הרצה וציור טבלאות מעקב משתנים.

רקורסיה נכונות: טענה 1: התוכנית sum עוצרת לכל n ≥ 1. מ-1 ו-2 האלגוריתם עוצר.  

רקורסיה טענה 2: לכל n המקיים 1≤n, האלגוריתם מחזיר את הערך 1 + 2 + … + n. מכיוון שבפתרון רקורסיבי בכל קריאה אנו מקטינים את הבעיה, אינדוקציה על גודל הקלט מתאימה מאוד להוכחת נכונות של אלגוריתמים רקורסיביים.   הוכחה באינדוקציה על n. מקרה בסיס: כאשר n=1, האלגוריתם מחזיר 1 כנדרש. הנחת האינדוקציה: נניח כי הטענה נכונה עבור 1≤k כלשהו. צעד האינדוקציה: כאשר האלגוריתם מופעל על קלט k+1, הקריאה הרקורסיבית היא על קלט k. על-פי הנחת האינדוקציה, הקריאה הרקורסיבית תחזיר את הסכום 1 + 2 + … + k. לכך מוסיף האלגוריתם את k+1 (הקלט של הקריאה הנוכחית) ומתקבל הסכום 1 + 2 + … + k + (k+1), אותו מחזיר האלגוריתם, כנדרש.

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

רקורסיה דוגמה 2 – משולש פסקל: תזכורת: משולש פסקל הוא סידור של מספרים בצורת משולש, הנבנה באופן הבא: הקודקוד העליון של משולש זה מכיל את המספר 1, וכל מספר במשולש מהווה את סכום שני המספרים שנמצאים מעליו (המספרים שנמצאים על שוקי המשולש הם כולם 1). n 0 1 1 1 1 2 1 2 1 3 1 3 3 1 4 1 4 6 4 1 5 1 5 10 10 5 1 m 0 1 2 3 4 5 המספר ה-m בשורה ה- n, נותן את התשובה לשאלה "בכמה דרכים שונות אפשר לבחור m עצמים מתוך n עצמים?" (מקדם בינומי).

רקורסיה נכתוב פונקציה רקורסיבית pascal(int n, int m) שתחשב את המספר המופיע בשורה n ובעמודה m במשולש פסקל. תאור האלגוריתם תנאי עצירה: אם m הוא 0 נחזיר ערך 1. אם n=m נחזיר ערך 1. חוקיות הקלט: n ו- m הם שלמים אי-שליליים. אם m>n נציין שיש שגיאה בקלט. קריאות רקורסיביות עם קלט קטן יותר: קריאה אחת עם n-1 ו- m (המספר מעליו) קריאה שנייה עם n-1 ו m-1 (המספר מעל ומשמאל) שילוב התוצאות לקבלת תשובה: החזרת סכום של הערכים שהתקבלו משני הקריאות הרקורסיביות.

רקורסיה // Pascal number in row n and column m. public static int pascal(int n, int m){ int ans ; if ((m<0) || (n<0) || (m>n)) ans = -1; else if ((m==0) || (n == m)) ans = 1; ans = pascal(n-1,m)+pascal(n-1,m-1); return ans ; }

רקורסיה דוגמה 3 – זוגיים ואי זוגיים: רוצים לבדוק האם מספר טבעי n זוגי או אי זוגי באמצעות הפונקציות even ו- odd (ללא פעולות חלוקה ושארית) public static boolean even(int n) { boolean ans; if (n == 0) ans = true; else ans = odd(n - 1); return ans; } public static boolean odd(int n) { if (n == 1) ans = even(n - 1);

רקורסיה מה קורה כאשר מפעילים את even על מספר אי-זוגי גדול מ-0? ניסיון שני: public static boolean odd(int n) { boolean ans; if (n == 0) ans = false; else ans = even(n - 1); return ans; } רקורסיה הדדית: even קוראת לעצמה דרך odd, ו- odd קוראת לעצמה דרך even.

סיכום מחרוזות: length, charAt, substring, equals, + מיון בועות רקורסיה: הרכיבים: תנאי עצירה קריאות רקורסיביות עם קלט קרוב יותר לתנאי העצירה שילוב התוצאות של הקריאות הרקורסיביות לקבלת התוצאה. הוכחות נכונות: עצירה, נכונות החישוב (אנדוקציה) רקורסיה הדדית