מיון הכנסה

אנימציה המסבירה כיצד פועל מיון הכנסה

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

זמן הריצה הממוצע של האלגוריתם הוא ${\displaystyle O(n^{2})}$ פעולות (בדומה למיון בועות).

תיאור האלגוריתם

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

דוגמה לקוד דמה עבור מערך המתחיל באינדקס 0 (כמו בשפת C):

 for j ←1 to length(A)-1
     key ← A[ j ]
     > A[ j ] is added in the sorted sequence A[0, .. j-1]
     i ← j - 1
     while i >= 0 and A [ i ] > key
         A[ i + 1 ] ← A[ i ]
         i ← i - 1
     A [i + 1] ← key

דוגמה למימוש עבור מערך מכל סוג נתונים שהוא (בשפת C):

void insert_sort (void *arr, size_t num, size_t size, int (*cmp) (const void *, const void *))
{
    void *key;
    size_t j;
    int i;
    
    key = malloc (size);
    
    for (j = 1 ; j < num ; j++)
    {
        memcpy (key, (void *) ((char *) arr + size * j), size);
        
        i = j - 1;
        while (i >= 0 && cmp ((char *) arr + size * i, key))
        {
            memcpy ((char *) arr + size * (i + 1), (char *) arr + size * i, size);
            memcpy ((char *) arr + size * i, key, size);
            
            i--;
        }
    }
    
    free (key);
}

חישוב סיבוכיות

המקרה הטוב ביותר הוא כאשר הקלט הוא מספר ממיון של אברים, כך שבכל איטרציה מעבר לפעולת השמירה של האיבר הנוכחי במשתנה העזר, נעשית רק פעולת השוואה אחת לאיבר הצמוד אליו מהאוסף שכבר מוין, זמן הריצה כולל מעבר על כל איברי האוסף כשלכל מעבר עוד שני פעולות כך שסך הכל יש כאן ${\displaystyle 3n}$ פעולות שזה בחישוב סיבוכיות ${\displaystyle O(n)}$.

המקרה הגרוע הוא כאשר כל האברים ממויינים בסדר הפוך כך שהמיון כולל מעבר על כל אברי האוסף, ובכל איטרציה מספר של i בדיקות לאורך כל המערך הממויין כך שמספר הפעולות שווה ל ${\displaystyle 1+2+3+\cdots +n-1}$ השווה ל-${\displaystyle n(n-1)/2}$ פעולות ולכן סיבוכיות זמן ריצה במקרה זה הוא ${\displaystyle O(n^{2})}$

המקרה הממוצע הוא כאשר המערך אינו ממויין וכולל השואות נוספות מעבר ל${\displaystyle n}$ איטרציות, כמובן שגם מקרה זה חסום ב ${\displaystyle O(n^{2})}$. אולם למרות סיבוכיות זמן הריצה לאוספים ממויינים ברובן (כגון אוסף ממויין שהוכנס לו איבר בודד שאינו ממויין) או לאוספים קטנים מאד מיון הכנסה יעיל יותר אפילו ממיונים מהירים כמו מיון מהיר, לעיתים ניתן לממש את המיון מהיר כך שאוספים קטנים עד סף מסויים (לרוב עד עשר) המיון יהיה לפי מיון הכנסה.

קישורים חיצוניים

ראו מדיה וקבצים בנושא זה בוויקישיתוף.

• מיון הכנסה בQueue