Key differences between Insertion Sort and Selection Sort

Insertion Sort

Insertion Sort is a simple and intuitive comparison-based sorting algorithm that builds the final sorted array one element at a time. It works much like sorting playing cards in your hands. Starting with the second element of the array, the algorithm compares the current element with those in the already sorted section on its left. It inserts the current element into its correct position by shifting all larger elements one position to the right. This process is repeated for each element until the whole array is sorted. Insertion Sort is efficient for small data sets or arrays that are already partially sorted but becomes inefficient for larger lists due to its quadratic time complexity, typically  𝑂(𝑛^2).

Functions of Insertion Sort:

  1. Sorting Elements:

Primary Function: Sorts elements in ascending or descending order. Each element from the unsorted part is picked and placed at the correct position in the sorted part.

  1. Stability Maintenance:

Preserves Order: Maintains the relative order of equal elements, making it a stable sorting algorithm. This is crucial in scenarios where the relationships between equivalent elements should remain unchanged after sorting.

  1. Adaptive Sorting:

Efficiency in Nearly Sorted Data: Works very efficiently with arrays that are already partially sorted. The time complexity can approach O(n) in best-case scenarios, where the data is nearly or completely sorted.

  1. In-Place Sorting:

Space Efficiency: Requires minimal extra space, as it sorts the array in place. This is an advantage when memory usage is a concern.

  1. Iterative Refinement:

Step-by-Step Sorting: Provides a good visualization of how a simple sorting algorithm can progressively organize data, making it educational and easy to understand.

  1. Data Insertion during Sorting:

Ease of Inserting New Elements: Because the sorted section is maintained at all times, inserting new elements into an already sorted array remains efficient, making Insertion Sort useful in dynamic, real-time sorting situations.

Example of Insertion Sort:

Here’s an example of how the Insertion Sort algorithm works, illustrated with a simple array of integers. Suppose we have the following array:


The goal is to sort this array in ascending order using Insertion Sort. Below is a step-by-step process of how the sorting is executed:

Initial Setup

  • Start with the second element, since a single-element array (the first element alone) is already considered sorted.

Step 1: Sort Element 3

  • Current Element: 3
  • Compare 3 with previous elements:
    • 3 < 5
  • Move 5 to the right, making room to insert 3.
  • Updated Array: [3, 5, 8, 4, 2]

Step 2: Sort Element 8

  • Current Element: 8
  • Compare 8 with previous elements:
    • 8 > 5 (no movement needed)
  • Updated Array: [3, 5, 8, 4, 2]

Step 3: Sort Element 4

  • Current Element: 4
  • Compare 4 with previous elements:
    • 4 < 8, move 8 to the right.
    • 4 < 5, move 5 to the right.
  • Insert 4 into the correct position.
  • Updated Array: [3, 4, 5, 8, 2]

Step 4: Sort Element 2

  • Current Element: 2
  • Compare 2 with previous elements:
    • 2 < 8, move 8 to the right.
    • 2 < 5, move 5 to the right.
    • 2 < 4, move 4 to the right.
  • Insert 2 into the correct position.
  • Updated Array: [2, 3, 4, 5, 8]

Final Sorted Array

  • Result: [2, 3, 4, 5, 8]

Selection Sort

Selection Sort is a straightforward comparison-based sorting algorithm that divides the input array into two parts: a sorted subsection and an unsorted subsection. The process begins by finding the smallest (or largest, depending on sorting order) element in the unsorted section and swapping it with the leftmost unsorted element. This element then becomes part of the sorted section. This procedure is repeated for each position in the array until the entire list is sorted. Although simple, Selection Sort is not suitable for large datasets as it has a time complexity of (𝑛^2), where 𝑛n is the number of items to be sorted. It performs the same number of comparisons regardless of the initial order of the items.

Functions of Selection Sort:

  1. Simplifying Sorting:

Core Function: Simplifies the sorting process by repeatedly selecting the smallest or largest element from the unsorted portion of the list and moving it to the end of the sorted portion.

  1. Minimizing Swaps:

Reduction in Swap Operations: Compared to some other algorithms like Bubble Sort, Selection Sort minimizes the number of swap operations, as it makes only one swap per pass through the remaining unsorted elements.

  1. Ease of Implementation:

Straightforward Algorithm: Its algorithmic structure is simple and intuitive, making it easy to implement and understand, which is particularly useful for educational purposes and for introducing the concepts of sorting.

  1. Memory Efficiency:

In-Place Sorting: Operates in place, requiring no additional temporary storage other than space for a few variables. This minimal space requirement makes it memory efficient.

  1. Performance Consistency:

Consistent Running Time: Provides consistent performance regardless of the initial order of the elements. The time complexity is always (𝑛2)O(n2), making its performance predictable.

  1. Non-Adaptive:

Uniform Operations: The algorithm does not adapt based on the initial order of data. It performs the same steps, whether the data is already sorted, partially sorted, or in reverse order.

  1. Fixed Number of Comparisons:

Deterministic Comparisons: Makes a fixed number of comparisons, determined by the size of the input array, which is useful for analysis in theoretical computer science.

Example of Selection Sort:

Here’s a practical example of how the Selection Sort algorithm works, using a simple array of integers. Let’s say we have the following array:


The goal is to sort this array in ascending order using Selection Sort. Below, I’ll detail the step-by-step process of sorting this array:

Initial Setup

  • The array is initially unsorted, and we begin with the entire array considered unsorted.

Step 1: Find the Minimum and Swap

  • Unsorted Section: 29,10,14,37,1329,10,14,37,13
  • Find the smallest element in the unsorted section (10).
  • Swap it with the first element (29).
  • Updated Array: 10,29,14,37,1310,29,14,37,13

Step 2: Find the Minimum in Remaining Unsorted and Swap

  • Unsorted Section: 29,14,37,1329,14,37,13 (starting from the second element)
  • Find the smallest element (13).
  • Swap it with the first element of the unsorted section (29).
  • Updated Array: 10,13,14,37,2910,13,14,37,29

Step 3: Find the Minimum in Remaining Unsorted and Swap

  • Unsorted Section: 14,37,2914,37,29 (starting from the third element)
  • The smallest element in this section is 14, which is already in its place.
  • No swap needed.
  • Updated Array: 10,13,14,37,2910,13,14,37,29

Step 4: Find the Minimum in Remaining Unsorted and Swap

  • Unsorted Section: 37,2937,29 (starting from the fourth element)
  • Find the smallest element (29).
  • Swap it with the first element of the unsorted section (37).
  • Updated Array: 10,13,14,29,3710,13,14,29,37

Step 5: Last Element

  • The last element (37) is already in place as it is the only remaining element in the unsorted section.

Final Sorted Array

  • Result: 10,13,14,29,3710,13,14,29,37

Key differences between Insertion Sort and Selection Sort

Aspect Insertion Sort Selection Sort
Complexity in Best Case O(n) O(n^2)
Complexity in Average Case O(n^2) O(n^2)
Complexity in Worst Case O(n^2) O(n^2)
Memory Usage In-place, no extra space In-place, no extra space
Stability Stable Unstable
Number of Comparisons Depends on initial order Always n(n-1)/2
Number of Swaps Variable, fewer than Selection N-1 swaps
Online Capability Can sort new elements as added Cannot sort new elements
Method of Sorting Insertion Selection
Adaptiveness Adaptive to initial order Not adaptive
Efficiency with Small Data Efficient for small arrays Less efficient than Insertion
Performance on Sorted Data Very fast No improvement
Ease of Implementation Relatively simple Simpler than Insertion
Typical Use Case Small or nearly sorted data When memory is limited
Visualization Good for demonstrating sorting Shows minimum selection

Key Similarities between Insertion Sort and Selection Sort

  • Complexity Class:

Both algorithms fall into the category of O(n^2) for their average and worst-case performance, making them less suitable for large datasets but manageable for smaller or nearly sorted arrays.

  • In-Place Sorting:

Both Insertion Sort and Selection Sort operate in-place, meaning they require no additional memory other than a small amount for temporary variables. This attribute makes them memory efficient.

  • Simplicity:

They are conceptually simple and easy to understand, which makes them excellent teaching tools for explaining basic sorting mechanisms and algorithm design principles.

  • No Additional Memory Needed:

As in-place sorting algorithms, neither Insertion Sort nor Selection Sort requires additional arrays or significant memory overhead, which is ideal for environments with limited memory resources.

  • Nature of Sorting:

Both sorts incrementally improve the order of the list, either by inserting one element at a time into its correct position (Insertion Sort) or by selecting the minimum element and moving it into position (Selection Sort).

  • Stability:

While Insertion Sort is stable, meaning that it preserves the relative order of records with equal keys, Selection Sort typically does not provide stability; however, both can be modified to address stability if needed.

error: Content is protected !!