Insertion Sort in Java

Insertion sort is a simple sorting algorithm that puts together the final sorted array element by element. It loops through an array and extracts one component from the beginning data to insert it into the right place at the already sorted section of the array. The concept behind insertion sort is to retain a sorted sublist in the lower positions of the array and, at the same time, move the new elements to their right place by inserting these into the sublist.

Here are some situations when it is appropriate to use insertion sort:

Small datasets: Insertion sort has a time complexity of O(n^2), so it can turn inefficient for large data. Conversely, for small datasets (e.g., less than 100 items), insertion sort can be faster than complex algorithms that have greater complexity and lower overhead.

Nearly sorted datasets: If the input dataset is almost sorted by itself, insertion sort would be an effective algorithm because it would still need to perform a small number of swaps or comparisons to arrange the elements in the correct order.

Online sorting: Insertion sort can be used in scenarios in which elements are constantly added to a list or array in a real-time mode. As new elements are added, its incremental nature lends itself to managing the maintenance of a sorted list.

Adaptive sorting: Insertion sort is an adaptive sorting algorithm, which means it outperforms partially sorted datasets compared to totally unsorted datasets. If the input data set is partially ordered or contains few elements out of the context of order, the insertion sort algorithm will soon regain control and sort the elements fast.

Playlist Management in Music Applications: Concerning music apps, users may often do it by putting in the tracks one after another. As new songs are being added, sorting will remain dynamic within the playlist by ensuring the sorted order of the list based on criteria like song title, artist name or release date.

Simple Sorting Tasks in Embedded Systems: In embedded systems with lower computational resources, the insertion sort may be used for sorting small arrays or lists because of its easiness and small amount of memory space. For instance, the accomplishment of small-scale tasks such as sorting sensor readings or processing small datasets in IoT devices.

How insertion sort works?

Recurrently, an element is taken from the unsorted area of the array and is inserted in its correct order within the sorted sublist. undefined

Start with the Second Element: Let us imagine that the first part of the array is already sorted. From the second element (index 1) of the array start the iteration.

Compare and Insert: For each item in the unsorted part of the array:

• Compare the current element with the elements on the right side of the sorted sublist, starting from its rightmost elements.
• Move elements toward the right that are greater than the one being compared one position ahead.
• Insert the current element where it fits in the sorted sublist.

Repeat: Keep on moving this way and keep on expanding the sorted sublist with every iteration.

Final Sorted Array: After these steps, the array will be completely sorted.

Let's walk through the insertion sort process step by step for the example array [1, 3, 7, 9, 16, 5].

Initial Array: [1, 3, 7, 9, 16, 5]

Iteration 1 (Starting from index 1):

• Take the second element 3.
• Compare 3 with 1 (the only element in the sorted sublist).
• Since 3 is greater than 1, it stays in its current position.
• Array remains: [1, 3, 7, 9, 16, 5].

Iteration 2 (Starting from index 2):

• Take the third element 7.
• Compare 7 with elements in the sorted sublist (3 and 1).
• Since 7 is greater than 3 and 1, it stays in its current position.
• Array remains: [1, 3, 7, 9, 16, 5].

Iteration 3 (Starting from index 3):

• Take the fourth element 9.
• Compare 9 with elements in the sorted sublist (7, 3, and 1).
• Since 9 is greater than all elements in the sorted sublist, it stays in its current position.
• Array remains: [1, 3, 7, 9, 16, 5].

Iteration 4 (Starting from index 4):

• Take the fifth element 16.
• Compare 16 with elements in the sorted sublist (9, 7, 3, and 1).
• Since 16 is greater than all elements in the sorted sublist, it stays in its current position.
• Array remains: [1, 3, 7, 9, 16, 5].

Iteration 5 (Starting from index 5):

• Take the sixth element 5.
• Compare 5 with elements in the sorted sublist (16, 9, 7, 3, and 1).
• Insert 5 between 3 and 7.
• Array becomes: [1, 3, 5, 7, 9, 16].

After iterating through all elements, the array is fully sorted: [1, 3, 5, 7, 9, 16].

Implementation of Insertion Sort Algorithm

InsertionSortExample.java

Output:

Before Insertion Sort
9 14 3 2 43 11 58 22 
After Insertion Sort
2 3 9 11 14 22 43 58 

Time Complexity

Worst Case: O(n^2)

Best Case: O(n)

Average Case: O(n^2)

The worst case is when the array is in reverse sorted order; insertion sort has to perform n^2/2 comparisons and swaps. Nevertheless, in the best-case scenario, when the array has been sorted, insertion sort just requires n - 1 comparisons and no swaps.

Space Complexity

O(1)

Insertion sort sorts list in place. Hence, it uses no extra space, which is proportional to the size of the input list. Consequently, the space complexity is constant, expressed as O(1).

Advantages of Insertion Sort Algorithm

Simple Implementation: Implementation of insertion sort is much easier, and hence, it can be employed for pedagogical settings or situations where performance is not a key consideration.

Efficient for Small Data Sets: It functions well with small datasets or for almost sorted arrays. When the array is already partially sorted, insertion sort runtime is proportional to the input size, which makes it faster compared to the more complex algorithms.

Adaptive: The insertion sort is adaptive; that is, it is able to effectively manage arrays that are partially sorted already. It adjusts its approach depending on the initial placement of elements, potentially saving the number of comparisons and swaps that the algorithm needs to perform.

Stable Sorting Algorithm: Insertion sort is a stabilizing sorting algorithm that handles the relative order of the same elements. This property is the key to dealing with things such as multi-key sorting and the case when the natural order of similar elements should be preserved.

In-Place Sorting: It arranges the array in place, occupying additional space of O(1) regardless of the array dimension. By making it memory efficient and suitable for sorting large datasets using limited memory resources, it achieves this.

Disadvantages of Insertion Sort Algorithm:

Quadratic Time Complexity: The worst-case time complexity of the insertion sort is O(n^2), as the number of elements in the array is denoted by n. This is why a bucket sort becomes inefficient when applied to large data sets because the number of comparisons and swaps is proportional to the square of the input size.

Not Suitable for Large Data Sets: As its time complexity is quadratic, insertion sort is inapplicable for organizing huge amount of data. As the size of an array grows, it can take up a lot of time sorting the array.

Not as Efficient as Merge Sort or Quick Sort: Although it's a good match for small data sets or nearly sorted arrays, insertion sort becomes inferior to more efficient algorithms, including merge sort and quicksort, when the size of the dataset increases. These types of algorithms generally provide better average and worst-case time complexities.

Non-Adaptive in General: Although insertion sort typically performs better for nearly sorted arrays, it doesn't invariably perform better due to the original order of elements. On the contrary, algorithms like mergesort and quicksort can have the best average case behaviour independent of the input order.

Limited Use in Practical Applications: Insertion sort, which is frequently used as a component part of more complex algorithms or as a teaching tool, is less frequently adopted for practical applications where performance requirements are essential. With the use of such cases the more optimized sorting algorithms are preferred.