מיונים וחיפושים קרן כליף

ביחידה זו נלמד: מהו מיון מוטיבציה למיון מיון בועות (Bubble Sort) מיון בסדר עולה מיון בסדר יורד Insertion Sort Selection Sort חיפוש בינארי מיזוג מערכים ממוינים 2 © Keren Kalif

מהו מיון מיון הוא סידור איברי קבוצה מסוימת בסדר עולה או בסדר יורד הקבוצה היחידה שאנו מכירים עד כה היא מערך, לכן נראה כיצד ממיינים מערך 3 1 9 2 מערך לא ממוין: 1 2 3 9 מערך ממוין: 3 © Keren Kalif

מוטיבציה למיון – שיקולי יעילות בחיפוש ערך מסוים כדי למצוא את האיבר המינימאלי במערך, צריך לסרוק את כל האיברים (חיפוש לינארי) יעילות: O(n) אם המערך ממוין צריך לבדוק מהו ערכו של האיבר הראשון בלבד יעילות: O(1) כדי למצוא את האיבר המקסימאלי במערך, צריך לסרוק את כל האיברים (חיפוש לינארי) אם המערך ממוין צריך לבדוק מהו ערכו של האיבר האחרון בלבד 4 © Keren Kalif

מוטיבציה למיון – שיקולי יעילות בחיפוש ערך מסוים (2) כדי למצוא איבר כלשהו, צריך לסרוק את כל האיברים יעילות: O(n) אם המערך ממוין ניתן למצוא את האיבר ב- O(log(n)) שזה שיפור בסדר גודל שלם! כדי למצוא איבר במערך ממוין בסדר גודל של O(log(n)) נשתמש בחיפוש בינארי 5 © Keren Kalif

מיון בועות הרעיון מאחורי מיון בועות (עבור מיון מהערך הקטן לגדול): באיטרציה הראשונה נפעפע את האיבר המקסימלי לסוף המערך ונמקם אותו במקום ה- n-1 ע"י החלפות באיטרציה השניה נפעפע את האיבר המקסימלי מבין האיברים 0 עד n-2 ונמקם אותו במקום ה- n-2 ע"י החלפות וכו' עד סוף המערך המצב בסיום האיטרציה ה- k שיש לנו את k האיברים הגדולים ביותר במערך ממוינים ב- k האיברים האחרונים הרעיון מאחורי השם הוא שמבעבעים את האיבר המתאים למעלה ע"י החלפות 6 © Keren Kalif

מיון בועות – דוגמת הרצה 1 3 2 9 1 3 9 2 3 1 9 2 1 2 3 9 אם האיבר השמאלי גדול מהימני, נחליף בינהם החלף 1 < 3 ? 9 < 3 ? החלף 2 < 9 ? המצב כעת הוא שהאיבר המקסימלי אכן נמצא בסוף, ונתייחס רק למערך שמשמאל לקו 3 < 1 ? החלף 2 < 3 ? המצב כעת הוא ששני האיברים המקסימאלים אכן נמצאים ממוינים בסוף, ונתייחס רק למערך שמשמאל לקו 2 < 1 ? 7 © Keren Kalif

ניתוח זמן ריצה: O(arr.length2) מיון בועות - הקוד public static void main(String[] args) { int arr[] = {3,8,1,4}; for ( ; ; ) { for ( ; ; ) { if (arr[j] > arr[j+1]) { int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } for (i=0 ; i < arr.length ; i++) System.out.println(arr[i] + “ “); System.out.println(); int[]: arr int: i 3 int: j 2 int: temp 8 int[]: arr int: I 1 int: j 2 int: temp 3 int[]: arr int: i 3 int: j 1 int: temp 8 int[]: arr int: i 2 int: j int: temp 3 int[]: arr int: i 2 int: j 3 int: temp 8 int[]: arr int: i 2 int: j int: temp 3 int[]: arr int: i 2 int: j int: temp 8 int[]: arr int: i ??? int: j int: temp int[]: arr int: i 1 int: j int: temp 3 int[]: arr int: i int: j 1 int: temp 3 int[]: arr int: i 1 int: j int: temp 3 int[]: arr int: i 3 int: j int: temp 8 int[]: arr int: i 2 int: j 1 int: temp 3 int[]: arr int: i 3 int: j int: temp ??? int[]: arr int: i 3 int: j 1 int: temp ??? int[]: arr int: i 3 int: j ??? int: temp int i=arr.length-1 i > 0 i-- int j=0 j < i j++ 1 2 3 1 3 4 8 3 1 8 4 3 1 4 8 3 8 1 4 ניתוח זמן ריצה: O(arr.length2) 8 © Keren Kalif

מיון בועות – קצת סדר ופונקציות (1) מיון בועות – קצת סדר ופונקציות (1) public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void main(String[] args) {() { int arr[] = {3,8,1,4}; for (int i=arr.length-1 ; i > 0 ; i-- ) { for (int j=0 ; j < i ; j++ ) { if (arr[j] > arr[j+1]) swap(arr, j, j+1); for (i=0 ; i < size ; i++) System.out.print(arr[i] + “ “); System.out.println(); 9 © Keren Kalif

מיון בועות – קצת סדר ופונקציות (2) public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void sortAscending(int arr[]) { for (int i=arr.length-1 ; i > 0 ; i-- ) { for (int j=0 ; j < i ; j++ ) { if (arr[j] > arr[j+1]) swap(arr, j, j+1); public static void main(String[] args) { int arr[] = {3,8,1,4}; sortAscending(arr); for (int i=0 ; i < arr.length ; i++) System.out.print(arr[i] + “ “); System.out.println(); ניתוח יעילות: כמות הפעולות בכל איטרציה קטן באחד  נסכום את כמות הפעולות  זמן הריצה הוא O(arr.length2) 10 © Keren Kalif

מיון בועות – השינוי עבור מערך ממוין בסדר יורד public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void sortDescending(int arr[]) { for (int i=arr.length-1 ; i > 0 ; i-- ) { for (int j=0 ; j < i ; j++ ) { if (arr[j] < arr[j+1]) swap(arr, j, j+1); public static void main(String[] args) { int arr[] = {3,8,1,4}; sortDescending(arr); for (int i=0 ; i < arr.length ; i++) System.out.print(arr[i] + “ “); System.out.println(); כדי למיין את המערך בסדר יורד, נרצה לפעפע את האיבר הקטן ביותר לסוף. לכן השינוי היחידי הוא בתנאי לפני ההחלפה (וכמובן ששם הפונקציה) 11 © Keren Kalif

מיון בועות: אופטימיזציה public static void sort(int arr[]) { boolean hasChanged=true; for (int i=arr.length-1 ; i > 0 && hasChanged ; i-- ) } hasChanged = false; for (int j=0 ; j < i ; j++ ) { if (arr[j] > arr[j+1]) { swap(arr, j, j+1); hasChanged = true; { התוספת: לאחר איטרציה ללא כל החלפה, ברור כי המערך כבר ממוין ולכן נפסיק 12 © Keren Kalif

Selection Sort במיון זה מחפשים באיטרציה הראשונה את הערך המינימלי ושמים אותו באינדקס ה- 0, ובמקומו שמים את הערך שהיה באינדקס ה- 0 באיטרציה השניה מחפשים את הערך הנמוך ביותר החל מאינדקס 1, ומחליפים אותו עם הערך באינדקס 1 וכו' 3 5 7 8 8 5 7 3 min min min 13 © Keren Kalif

יעילות: סכום של סדרה חשבונית ולכן O(arr.length2) Selection Sort - הקוד public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void selectionSort(int[] arr) { for (int i=0 ; i < arr.length ; i++) { int minIndex = i; for (int j=i+1 ; j < arr.length ; j++) { if (arr[j] < arr[minIndex]) minIndex = j; swap(arr, i, minIndex); public static void main(String[] args) { int[] arr = {5,2,8,1,3}; selectionSort(arr); יעילות: סכום של סדרה חשבונית ולכן O(arr.length2) 14 © Keren Kalif

Insertion Sort הרעיון: נכניס כל איבר למקומו http://www.youtube.com/watch?v=ROalU379l3U הרעיון: נכניס כל איבר למקומו 4 3 5 2 4 3 5 2 3 4 5 2 3 4 5 2 2 3 4 5 3 2 4 5 3 4 2 5 3 4 5 2 15 © Keren Kalif

יעילות: סכום של סדרה חשבונית ולכן O(arr.length2) Insertion Sort - הקוד public static void insertionSort(int[] arr) { for (int i=1 ; i < arr.length ; i++) { for (int j=i ; j > 0 && arr[j-1] > arr[j] ; j--) { int temp = arr[j]; arr[j] = arr[j-1]; arr[j-1] = temp; } public static void main(String[] args) { int[] arr = {7,1,8,2,3,6,4,5}; insertionSort(arr); יעילות: סכום של סדרה חשבונית ולכן O(arr.length2) 16 © Keren Kalif

חיפוש בינארי הפונקציה מקבלת: הפונקציה מחזירה: מטרתו של חיפוש בינארי היא למצוא את מיקומו של איבר במערך ממוין לא ניתן להפעיל חיפוש בינארי על מערך לא ממוין! הגדרתו: public static int binarySearch(int[] arr, int value) הפונקציה מקבלת: מערך וערך לחיפוש הפונקציה מחזירה: את האינדקס של האיבר, או 1- אם לא נמצא 17 © Keren Kalif

חיפוש בינארי - הרעיון כל עוד יש במערך איברים: נחזיר 1- (לא מצאנו..) נבדוק האם האיבר שאנחנו מחפשים הוא האמצעי אם כן, נחזיר את האינדקס שלו אחרת אם הוא קטן מהאיבר האמצעי, נחפש אותו בחצי המערך השמאלי אחרת, נחפש אותו בחצי המערך הימני נחזיר 1- (לא מצאנו..) דוגמא, נחפש את הערך 39 במערך: 1 2 3 4 5 6 7 8 9 10 3 4 7 14 22 34 37 39 40 44 50 3 4 7 14 22 34 37 39 40 44 50 3 4 7 14 22 34 37 39 40 44 50 18 © Keren Kalif

חיפוש בינארי - ניתוח זמן ריצה בכל איטרציה מספר הפעולות קבוע בכל איטרציה גודל הקלט שלנו קטן פי 2, לכן יהיו לנו log(n) איטרציות בסה"כ זמן החישוב במקרה הגרוע ביותר הוא O(log(n)), לעומת O(n) בחיפוש לינארי שמו של חיפוש בינארי בא מכך שאנו מטפלים בכל איטרציה ב- ½ מהקלט (בינארי=2) 19 © Keren Kalif

חיפוש בינארי – הקוד (חיפוש 4) public static int binarySearch(int a[], int val) { int low=0,high=a.length-1, middle; while (low <= high) { middle = (low + high)/2; if (val == a[middle]) return middle; else if (val < a[middle]) high = middle -1; else low = middle +1; } return -1; public static void main(String[] args) { Scanner s = new Scanner(System.in); int arr[] = {1, 4, 7, 9, 12, 16}, index, value; System.out.print("Please enter the value to search: "); value = s.nextInt(); index = if (index == -1) System.out.printf("The value %d doesn't exist in the array\n", value); System.out.printf("The value %d exists in index %d\n", value, index); חיפוש בינארי – הקוד (חיפוש 4) int[]: a int: val 4 int: low int: high 5 int: middle 2 int[]: a int: val 4 int: low int: high 1 int: middle 2 int[]: a int: val 4 int: low int: high 1 int: middle int[]: a int: val 4 int: low int: high 5 int: middle ?? int[]: a int: val 4 int: low 1 int: high int: middle int[]: a int: val 4 int: low ?? int: high int: middle int[]: a int: val 4 int: low 1 int: high int: middle int[]: arr int: index 1 int: value 4 int[]: arr int: index ?? int: value 4 int[]: arr int: index ?? int: value הזיכרון של ה- main הזיכרון של binarySearch 1 2 3 4 5 1 4 7 9 12 16 low middle high low middle high middle binarySearch(arr, value); 20 © Keren Kalif

חיפוש בינארי – הקוד (חיפוש 10) int binarySearch(int a[], int val) { int low=0,high=a.length-1, middle; while (low <= high) { middle = (low + high)/2; if (val == a[middle]) return middle; else if (val < a[middle]) high = middle -1; else low = middle +1; } return -1; public static void main(String[] args) { Scanner s = new Scanner(System.in); int arr[] = {1, 4, 7, 9, 12, 16}, index, value; System.out.print("Please enter the value to search: "); value = s.nextInt(); index = if (index == -1) System.out.printf("The value %d doesn't exist in the array\n", value); System.out.printf("The value %d exists in index %d\n", value, index); חיפוש בינארי – הקוד (חיפוש 10) int[]: a int: val 10 int: low 3 int: high int: middle int[]: a int: val 10 int: low 3 int: high 5 int: middle 4 int[]: a int: val 10 int: low 3 int: high int: middle 4 int[]: a int: val 10 int: low 3 int: high 5 int: middle 2 int[]: a int: val 10 int: low int: high 5 int: middle ?? int[]: a int: val 10 int: low int: high 5 int: middle 2 int[]: a int: val 10 int: low 4 int: high 3 int: middle int[]: a int: val 10 int: low ?? int: high int: middle int[]: arr int: index 1- int: value 10 int[]: arr int: index ?? int: value int[]: arr int: index ?? int: value 10 הזיכרון של binarySearch הזיכרון של ה- main 1 2 3 4 5 1 4 7 9 12 16 low middle low middle high low high middle binarySearch(arr, value); 21 © Keren Kalif

מיזוג מערכים ממוינים כל עוד יש איברים בשני המערכים: נבדוק האם האיבר הנוכחי במערך הראשון קטן/שווה מהאיבר הנוכחי במערך השני: אם כן, נעתיק איבר נוכחי מהמערך הראשון לנוכחי בשלישי ונקדם את מיקום האיבר הנוכחי אחרת, נעתיק איבר נוכחי מהמערך השני לנוכחי בשלישי ונקדם את מיקום האיבר הנוכחי נעתיק את כל מה שנותר מהמערך הראשון לשלישי נעתיק את כל מה שנותר מהמערך השני לשלישי רק אחד מהם יקרה... 1 3 2 1 4 3 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 22 © Keren Kalif

מיזוג מערכים ממוינים - הקוד public static int[] mergeArrays(int arr1[], int arr2[]) { int[] res = new int[arr1.length + arr2.length]; int i=0, j=0; while ( i < arr1.length && j < arr2.length ) { if (arr1[i] <= arr2[j]) res[i+j] = arr1[i++]; else res[i+j] = arr2[j++]; { while ( i < arr1.length) // copy rest of arr1 while ( j < arr2.length) // copy rest of arr2 return res; 1 3 i = 0 i = 2 i = 1 j = 3 j = 1 j = 2 j = 0 arr1: 2 1 4 3 arr2: 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 res: ניתוח זמן ריצה: O(arr1.length + arr2.length) 23 © Keren Kalif

ביחידה זו למדנו: מהו מיון מוטיבציה למיון מיון בועות (Bubble Sort) מיון בסדר עולה מיון בסדר יורד Insertion Sort Selection Sort חיפוש בינארי מיזוג מערכים ממוינים 24 © Keren Kalif

תרגיל 1: כתוב פונקציה המקבלת מטריצה ריבועית, אשר תמיין את ערכי האלכסון הראשי מהקטן לגדול דוגמא: עבור המטריצה יש לעדכנה להיות 25 © Keren Kalif

תרגיל 2: כתוב פונקציה המקבלת מחרוזת הכוללת אותיות קטנות וגדולות כתוב פונקציה המקבלת מחרוזת הכוללת אותיות קטנות וגדולות הפונקציה תמיין את אותיות המחרוזת מהאות הקטנה לגדולה, אך לא תבדיל בין אותיות גדולות לקטנות דוגמאות: עבור המחרוזת zBa הפונקציה תמיין אותה להיות aBz עבור הפונקציה zZaAC הפונקציה תמיין אותה להיות aACzZ הנחה: כאשר יש אות גדולה וקטנה זהה, לא משנה מי תופיע קודם 26 © Keren Kalif