logo

מיון הכנסה בפייתון

מיון ה-Insertion הוא אלגוריתם פשוט ויעיל יותר מאלגוריתם מיון הבועות הקודם. תפיסת אלגוריתם מיון ההכנסה מבוססת על חפיסת הקלף שבה אנו ממיינים את קלף המשחק לפי קלף מסוים. יש לזה יתרונות רבים, אבל יש הרבה אלגוריתמים יעילים זמינים במבנה הנתונים.

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

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

אלגוריתם מיון ההכנסה אינו מהיר כל כך בגלל שהוא משתמש בלולאה מקוננת למיון האלמנטים.

נורמליזציה של rdbms

בואו נבין את המונחים הבאים.

מה הפירוש של במקום ויציב?

    במקום:האלגוריתם במקום דורש שטח נוסף מבלי לדאוג לגודל הקלט של האוסף. לאחר ביצוע המיון, הוא משכתב את מיקומי הזיכרון המקוריים של האלמנטים באוסף.יַצִיב:היציב הוא מונח שמנהל את הסדר היחסי של עצמים שווים מהמערך הראשוני.

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

הדבר הגדול במיון ההוספה הוא שאם נכניס את יותר האלמנטים שיש למיין - האלגוריתם מסדר את המיון במקומו הנכון מבלי לבצע את המיון המלא.

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

המושג מיון הכנסה

המערך נשפך למעשה בשני החלקים במיון ההכנסה - An חלק לא ממוין ו מְמוּיָן חֵלֶק.

החלק הממוין מכיל את האלמנט הראשון של המערך ותת חלק אחר לא ממוין מכיל את שאר המערך. האלמנט הראשון במערך הלא ממוין מושווה למערך הממוין כדי שנוכל למקם אותו בתת-מערך תקין.

הוא מתמקד בהכנסת האלמנטים על ידי הזזת כל האלמנטים אם הערך בצד ימין קטן מהצד השמאלי.

זה יקרה שוב ושוב עד שהאלמנט הכל יוכנס במקום הנכון.

כדי למיין את המערך באמצעות מיון הכנסה למטה הוא האלגוריתם של מיון הכנסה.

  • נשפך רשימה בשני חלקים - ממוין ולא ממוין.
  • חזור מ-arr[1] ל-arr[n] על פני המערך הנתון.
  • השווה את האלמנט הנוכחי לאלמנט הבא.
  • אם האלמנט הנוכחי קטן מהאלמנט הבא, השווה לאלמנט הקודם, עברו לאלמנטים הגדולים יותר במיקום אחד למעלה כדי לפנות מקום לאלמנט שהוחלף.

בואו נבין את הדוגמה הבאה.

נשקול את אלמנט ראשון בתוך ה מערך ממוין במערך הבא.

[10, 4, 25, 1, 5]

הצעד הראשון ל להוסיף 10 למערך המשנה הממוין

[ 10 , 4, 25, 1, 5]

כעת ניקח את האלמנט הראשון מהמערך הלא ממוין - 4. אנו מאחסנים ערך זה במשתנה חדש טמפ' עַכשָׁיו , נוכל לראות שה-10>4 ואז נעביר את ה-10 ימינה וזה מחליף את ה-4 שהיה מאוחסן קודם לכן.

[ 10 , 10, 25, 1, 5] (טמפ' = 4)

כאן ה-4 קטן יותר מכל האלמנטים בתת-מערך ממוין, אז אנחנו מכניסים אותו במיקום האינדקס הראשון.

[ 4, 10, 25, 1, 5]

פקודת sed

יש לנו שני אלמנטים במערך המשנה הממוין.

עכשיו בדוק את המספר 25. שמרנו אותו בטמפ' מִשְׁתַנֶה. 25> 10 וגם 25> 4 ואז אנחנו שמים אותו במיקום השלישי ונוסיף אותו למערך המשנה הממוין.

[ 4, 10, 25, חֲמֵשׁ עֶשׂרֵה]

k השכן הקרוב

שוב אנחנו בודקים את המספר 1. אנחנו שומרים אותו טמפ' 1 הוא פחות מ-25. הוא מחליף את ה-25.

[ 4, 10, 25, 25, 5] 10>1 ואז הוא מדרוס שוב

[ 4, 25, 10, 25, 5]

[ 25, 4, 10, 25, 5] 4>1 כעת שים את הערך של temp = 1

[ 1, 4, 10, 25 , 5]

כעת, יש לנו 4 אלמנטים במערך המשנה הממוין. 5<25 25 then shift to the right side and pass טמפ' = 5 לצד שמאל.

[ 1, 4, 10, 25 , 25] לשים טמפ' = 5

כעת, אנו מקבלים את המערך הממוין על ידי הוספת ערך הטמפ'.

[1, 4, 5, 10, 25]

המערך הנתון ממוין.

יישום

יישום ההחדרה קל יחסית. ניישם באמצעות מערך ה-Python של המספרים השלמים. בואו נבין את הדוגמה הבאה -

תוכנית פייתון

 # creating a function for insertion def insertion_sort(list1): # Outer loop to traverse through 1 to len(list1) for i in range(1, len(list1)): value = list1[i] # Move elements of list1[0..i-1], that are # greater than value, to one position ahead # of their current position j = i - 1 while j &gt;= 0 and value <list1[j]: list1[j + 1]="list1[j]" j -="1" return list1 # driver code to test above 5, 13, 8, 2] print('the unsorted list is:', list1) sorted insertion_sort(list1)) < pre> <p> <strong>Output:</strong> </p> <pre> The unsorted list is: [10, 5, 13, 8, 2] The sorted list1 is: [2, 5, 8, 10, 13] </pre> <p> <strong>Explanation:</strong> </p> <p>In the above code, we have created a function called <strong>insertion_sort(list1).</strong> Inside the function -</p> <ul> <li>We defined for loop for traverse the list from 1 to <strong>len(list1).</strong> </li> <li>In for loop, assigned a values of list1 in <strong>value</strong> Every time the loop will iterate the new value will assign to the value variable.</li> <li>Next, we moved the elements of list1[0&#x2026;i-1], that are greater than the <strong>value,</strong> to one position ahead of their current position.</li> <li>Now, we used the while to check whether the j is greater or equal than 0, and the <strong>value</strong> is smaller than the first element of the list.</li> <li>If both conditions are true then move the first element to the 0<sup>th</sup> index and reduce the value of j and so on.</li> <li>After that, we called the function and passed the list and printed the result.</li> </ul> <h2>Sorting Custom Objects</h2> <p>Python provides the flexibility to change the algorithm using a custom object. We will create a custom class and redefine the actual comparison parameter and try to keep the same code as the above.</p> <p>We would require to overload the operators in order to sort the objects in a different way. But, we can pass another argument to the <strong>insertion_sort()</strong> function by using the <strong>lambda</strong> function. The lambda function is a convenient when calling the sorting method.</p> <p>Let&apos;s understand the following example of sorting custom objects.</p> <p>First, we are defining the <strong>Point</strong> class:</p> <h3>Python Program</h3> <pre> # Creating Point class class Point: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return str.format(&apos;({},{})&apos;, self.a, self.b) def insertion_sort(list1, compare_function): for i in range(1, len(list1)): Value = list1[i] Position = i while Position &gt; 0 and compare_function(list1[Position - 1], Value): list1[Position] = list1[Position - 1] Position = Position - 1 list1[Position] = Value U = Point(2,3) V = Point(4,4) X = Point(3,1) Y = Point(8,0) Z = Point(5,2) list1 = [U,V,X,Y,Z] # We sort by the x coordinate, ascending insertion_sort(list1, lambda x, y: x.a &gt; y.a) for point in list1: print(point) </pre> <p> <strong>Output:</strong> </p> <pre> The points are in the sorted order (2,3) (3,1) (4,4) (5,2) (8,0) </pre> <p>Using the above code, we can sort the coordinate points. It will work for any type of the list.</p> <h2>Time Complexity in Insertion Sort</h2> <p>Insertion sort is a slow algorithm; sometimes, it seems too slow for extensive dataset. However, it is efficient for small lists or array.</p> <p>The time complexity of the insertion sort is - <strong>O(n<sup>2</sup>).</strong> It uses the two loops for iteration.</p> <p>Another important advantage of the insertion sort is that; it is used by the popular sorting algorithm called <strong>Shell sort.</strong> </p> <p>The auxiliary space in insertion sort: <strong>O(1)</strong> </p> <h2>Conclusion</h2> <p>Insertion sort is a simple and inefficient algorithm that has many advantages, but there are more efficient algorithms are available.</p> <p>In this tutorial, we have discussed the concept of the insertion sort and its implementation using the Python programming language.</p> <hr></list1[j]:>

הֶסבֵּר:

מתי יצא windows 7

בקוד לעיל, יצרנו פונקציה בשם insertion_sort(list1). בתוך הפונקציה -

  • הגדרנו עבור לולאה לחצות את הרשימה מ-1 עד לן(רשימה1).
  • In for loop, הוקצו ערכים של list1 in ערך בכל פעם שהלולאה תחזור על הערך החדש יוקצה למשתנה הערך.
  • לאחר מכן, העברנו את האלמנטים של list1[0…i-1], שהם גדולים מה- ערך, לעמדה אחת לפני המיקום הנוכחי שלהם.
  • כעת, השתמשנו ב-while כדי לבדוק אם ה-j גדול או שווה מ-0, וה- ערך קטן מהרכיב הראשון ברשימה.
  • אם שני התנאים נכונים, העבר את האלמנט הראשון ל-0ה'אינדקס ולהפחית את הערך של j וכן הלאה.
  • לאחר מכן, קראנו לפונקציה ועברנו את הרשימה והדפסנו את התוצאה.

מיון אובייקטים מותאמים אישית

Python מספק את הגמישות לשנות את האלגוריתם באמצעות אובייקט מותאם אישית. ניצור מחלקה מותאמת ונגדיר מחדש את פרמטר ההשוואה בפועל וננסה לשמור על אותו קוד כמו לעיל.

נדרוש להעמיס על המפעילים כדי למיין את האובייקטים בצורה אחרת. אבל, אנחנו יכולים להעביר טיעון נוסף ל insertion_sort() לתפקד על ידי שימוש ב- למבדה פוּנקצִיָה. פונקציית הלמבדה היא נוחה כאשר קוראים לשיטת המיון.

בואו נבין את הדוגמה הבאה למיון אובייקטים מותאמים אישית.

ראשית, אנו מגדירים את נְקוּדָה מעמד:

תוכנית פייתון

 # Creating Point class class Point: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return str.format(&apos;({},{})&apos;, self.a, self.b) def insertion_sort(list1, compare_function): for i in range(1, len(list1)): Value = list1[i] Position = i while Position &gt; 0 and compare_function(list1[Position - 1], Value): list1[Position] = list1[Position - 1] Position = Position - 1 list1[Position] = Value U = Point(2,3) V = Point(4,4) X = Point(3,1) Y = Point(8,0) Z = Point(5,2) list1 = [U,V,X,Y,Z] # We sort by the x coordinate, ascending insertion_sort(list1, lambda x, y: x.a &gt; y.a) for point in list1: print(point) 

תְפוּקָה:

 The points are in the sorted order (2,3) (3,1) (4,4) (5,2) (8,0) 

באמצעות הקוד לעיל, נוכל למיין את נקודות הקואורדינטות. זה יעבוד עבור כל סוג של הרשימה.

מורכבות זמן במיון הכנסה

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

מורכבות הזמן של מיון ההכנסה היא - עַל2). הוא משתמש בשתי הלולאות לאיטרציה.

יתרון חשוב נוסף של מיון ההחדרה הוא כי; הוא משמש את אלגוריתם המיון הפופולרי שנקרא מיון מעטפת.

רווח העזר במיון ההכנסה: O(1)

סיכום

מיון הכנסה הוא אלגוריתם פשוט ולא יעיל שיש לו יתרונות רבים, אך ישנם אלגוריתמים יעילים יותר זמינים.

במדריך זה, דנו במושג מיון ההוספה ומימושו באמצעות שפת התכנות Python.