Selection Sort (מיון בחירה)
עודכן לאחרונה
מיון בחירה מחלק את המערך לאזור ממוין משמאל ולאזור לא ממוין מימין. בכל מעבר הוא סורק את האזור הלא ממוין כדי למצוא את האיבר הקטן ביותר, ואז מחליף אותו למקום הלא ממוין הראשון, וכך האזור הממוין גדל באחד. לחצו על הפעלה למעלה כדי לראות את הסריקה וההחלפה, או עברו עליהן השוואה אחת בכל פעם.
מיון בחירה תמיד מבצע אותו מספר השוואות בלי קשר לקלט, אבל הוא מבצע לכל היותר n-1 החלפות, הרבה פחות ממיון בועות, וזה יכול להיות חשוב כשכתיבות יקרות.
סיבוכיות זמן וזיכרון
| מקרה | סיבוכיות | הערות |
|---|---|---|
| המקרה הטוב | O(n²) | ההשוואות מתבצעות גם אם המערך ממוין |
| המקרה הממוצע | O(n²) | סדר אקראי |
| המקרה הגרוע | O(n²) | ממוין בסדר הפוך |
| זיכרון | O(1) | במקום |
| יציב | לא | החלפות יכולות לשנות את הסדר של איברים שווים |
צעד אחר צעד
| צעד | מה קורה |
|---|---|
| 1 | מתייחסים למערך כולו כלא ממוין. |
| 2 | סורקים את האזור הלא ממוין כדי למצוא את האיבר המינימלי. |
| 3 | מחליפים את המינימום הזה למקום הלא ממוין הראשון. |
| 4 | מזיזים את הגבול צעד אחד ימינה (התא הזה ממוין עכשיו). |
| 5 | חוזרים על כך עד שנשאר רק איבר לא ממוין אחד. |
דוגמה מפורטת
מיון של [5, 2, 4, 1]:
| מעבר | מערך | פעולה |
|---|---|---|
| התחלה | [5, 2, 4, 1] | המערך כולו לא ממוין. |
| 1 | [1, 2, 4, 5] | סורקים את [5, 2, 4, 1], המינימום הוא 1 באינדקס 3; מחליפים אותו עם אינדקס 0. |
| 2 | [1, 2, 4, 5] | סורקים את [2, 4, 5], המינימום הוא 2 שכבר באינדקס 1; מחליפים אותו עם עצמו. |
| 3 | [1, 2, 4, 5] | סורקים את [4, 5], המינימום הוא 4 שכבר באינדקס 2; אין צורך בהזזה. |
| סיום | [1, 2, 4, 5] | נשאר רק 5, ולכן הוא כבר במקומו. |
מתי להשתמש במיון בחירה
| השתמשו בו כאשר | הימנעו ממנו כאשר |
|---|---|
כתיבות יקרות: הוא מבצע לכל היותר n-1 החלפות. | המערך גדול: ההשוואות של O(n²) שולטות. |
| אתם צריכים מיון במקום פשוט וקל למימוש. | אתם צריכים מיון יציב ששומר על הסדר של מפתחות שווים. |
הזיכרון מוגבל: הוא משתמש ב-O(1) זיכרון נוסף בלבד. | הנתונים כמעט ממוינים: הוא לא יכול לסיים מוקדם כמו מיון הכנסה. |
| כמות הנתונים זעירה וביצועים צפויים חשובים. | התפוקה חשובה: מיונים של O(n log n) כמו quicksort מהירים בהרבה. |
קוד Selection Sort
מימוש נקי של Selection Sort שאפשר להריץ, ב-Python, JavaScript, Java, C++, C, Pseudocode. בחרו שפה, העתיקו את הקוד, או פתחו אותו טעון מראש בעורך האונליין של Coddy.
קוד Selection Sort ב-Python
1def selection_sort(a):2 n = len(a)3 for i in range(n - 1):4 # Find the smallest element in the unsorted tail5 min_idx = i6 for j in range(i + 1, n):7 if a[j] < a[min_idx]:8 min_idx = j9 a[i], a[min_idx] = a[min_idx], a[i]10 return a11
12
13nums = [64, 25, 12, 22, 11]14print("Before:", nums)15selection_sort(nums)16print("After: ", nums)קוד Selection Sort ב-JavaScript
1function selectionSort(a) {2 for (let i = 0; i < a.length - 1; i++) {3 let min = i;4 // Find the smallest element in the unsorted tail5 for (let j = i + 1; j < a.length; j++) {6 if (a[j] < a[min]) min = j;7 }8 if (min !== i) [a[i], a[min]] = [a[min], a[i]];9 }10 return a;11}12
13const data = [5, 2, 9, 1, 7, 3];14console.log("Before:", data);15console.log("Sorted:", selectionSort([...data]));קוד Selection Sort ב-Java
1import java.util.Arrays;2
3public class Main {4 static void selectionSort(int[] arr) {5 for (int i = 0; i < arr.length - 1; i++) {6 int minIndex = i;7 // Find the smallest value in the unsorted part8 for (int j = i + 1; j < arr.length; j++) {9 if (arr[j] < arr[minIndex]) minIndex = j;10 }11 int tmp = arr[i];12 arr[i] = arr[minIndex];13 arr[minIndex] = tmp;14 }15 }16
17 public static void main(String[] args) {18 int[] arr = {29, 10, 14, 37, 13, 5};19 System.out.println("Before: " + Arrays.toString(arr));20 selectionSort(arr);21 System.out.println("After: " + Arrays.toString(arr));22 }23}קוד Selection Sort ב-C++
1#include <iostream>2#include <utility>3#include <vector>4
5void printVec(const std::vector<int>& a) {6 for (int x : a) std::cout << x << " ";7 std::cout << "\n";8}9
10void selectionSort(std::vector<int>& a) {11 for (size_t i = 0; i + 1 < a.size(); ++i) {12 // Find the smallest element in the unsorted suffix13 size_t minIdx = i;14 for (size_t j = i + 1; j < a.size(); ++j) {15 if (a[j] < a[minIdx]) minIdx = j;16 }17 std::swap(a[i], a[minIdx]);18 }19}20
21int main() {22 std::vector<int> data = {29, 10, 14, 37, 13, 5};23 std::cout << "Before: ";24 printVec(data);25 selectionSort(data);26 std::cout << "After: ";27 printVec(data);28 return 0;29}קוד Selection Sort ב-C
1#include <stdio.h>2
3void printArr(const int a[], int n) {4 for (int i = 0; i < n; i++) printf("%d ", a[i]);5 printf("\n");6}7
8void selectionSort(int a[], int n) {9 for (int i = 0; i < n - 1; i++) {10 // Find the smallest element in the unsorted suffix11 int minIdx = i;12 for (int j = i + 1; j < n; j++) {13 if (a[j] < a[minIdx]) minIdx = j;14 }15 int tmp = a[i];16 a[i] = a[minIdx];17 a[minIdx] = tmp;18 }19}20
21int main(void) {22 int data[] = {29, 10, 14, 37, 13, 5};23 int n = sizeof(data) / sizeof(data[0]);24 printf("Before: ");25 printArr(data, n);26 selectionSort(data, n);27 printf("After: ");28 printArr(data, n);29 return 0;30}קוד Selection Sort ב-Pseudocode
1DECLARE nums : ARRAY[1:7] OF INTEGER2DECLARE n : INTEGER3n ← 74nums[1] ← 75nums[2] ← 36nums[3] ← 97nums[4] ← 18nums[5] ← 59nums[6] ← 810nums[7] ← 211DECLARE i : INTEGER12DECLARE j : INTEGER13DECLARE minIndex : INTEGER14DECLARE temp : INTEGER15
16// Select the smallest remaining value and swap it into place17FOR i ← 1 TO n - 118 minIndex ← i19 FOR j ← i + 1 TO n20 IF nums[j] < nums[minIndex] THEN21 minIndex ← j22 ENDIF23 NEXT j24 IF minIndex <> i THEN25 temp ← nums[i]26 nums[i] ← nums[minIndex]27 nums[minIndex] ← temp28 ENDIF29NEXT i30
31FOR i ← 1 TO n32 OUTPUT nums[i]33NEXT iשאלות נפוצות על מיון בחירה
מהי סיבוכיות הזמן של מיון בחירה?
O(n²) בכל המקרים, הטוב, הממוצע והגרוע, כי הוא תמיד סורק את כל האזור הלא ממוין כדי למצוא כל מינימום. הוא משתמש ב-O(1) זיכרון נוסף.האם מיון בחירה יציב?
מתי מיון בחירה שימושי?
n-1 החלפות, המינימום האפשרי עבור מיון מבוסס השוואה שמזיז איברים.מה ההבדל בין מיון בחירה למיון בועות?
O(n²), אבל מיון בחירה מבצע לכל היותר n-1 החלפות, ואילו מיון בועות יכול לבצע עד O(n²) החלפות. מיון בועות יכול גם לזהות מערך שכבר ממוין ולעצור מוקדם, ואילו מיון בחירה תמיד מריץ את מספר המעברים המלא.האם להשתמש במיון בחירה או במיון הכנסה?
O(n) על נתונים כמעט ממוינים, ומהיר יותר בממוצע. בחרו במיון בחירה רק כשצמצום מספר הכתיבות הוא העדיפות, כי הוא מבטיח לכל היותר n-1 החלפות.למה מיון בחירה תמיד רץ ב-O(n²), גם על מערך ממוין?
O(n²), בניגוד למיון הכנסה או למיון בועות, שיכולים לקצר את הדרך.