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

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

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

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

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

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

7. מיון בועות – דוגמת הרצה 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

8. ניתוח זמן ריצה: 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

9. מיון בועות – קצת סדר ופונקציות (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

10. מיון בועות – קצת סדר ופונקציות (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

11. מיון בועות – השינוי עבור מערך ממוין בסדר יורד
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

12. מיון בועות: אופטימיזציה
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

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

14. יעילות: סכום של סדרה חשבונית ולכן 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

15. Insertion Sort הרעיון: נכניס כל איבר למקומו
הרעיון: נכניס כל איבר למקומו 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

16. יעילות: סכום של סדרה חשבונית ולכן 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

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

18. חיפוש בינארי - הרעיון כל עוד יש במערך איברים: נחזיר 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

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

20. חיפוש בינארי – הקוד (חיפוש 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

21. חיפוש בינארי – הקוד (חיפוש 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

22. מיזוג מערכים ממוינים כל עוד יש איברים בשני המערכים:
נבדוק האם האיבר הנוכחי במערך הראשון קטן/שווה מהאיבר הנוכחי במערך השני:
אם כן, נעתיק איבר נוכחי מהמערך הראשון לנוכחי בשלישי ונקדם את מיקום האיבר הנוכחי
אחרת, נעתיק איבר נוכחי מהמערך השני לנוכחי בשלישי ונקדם את מיקום האיבר הנוכחי
נעתיק את כל מה שנותר מהמערך הראשון לשלישי
נעתיק את כל מה שנותר מהמערך השני לשלישי
רק אחד מהם יקרה... 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

23. מיזוג מערכים ממוינים - הקוד
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

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

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

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