Home Sorting Arrays Search Stack Queue Linked Lists Trees Graphs Dynamic Programming Greedy Algorithms Backtracking String Algorithms LeetCode Patterns Contact

Sorting playground

Insertion Sort Visualizer

Take one value at a time and slide it left into the correct place inside an already-sorted prefix.

Array values (comma-separated, up to 20)

Playback speed

Live operation

sorted

Step 1 / 21

A value has reached a confirmed sorted position.

[0]

[1]

[2]

[3]

[4]

CompareShift / swapSorted prefix

Comparisons

Moves / writes

Confirmed sorted

1 / 5

Algorithm notes

What to watch for

Insertion Sort treats the left side of the array like a growing hand of cards. Each new value compares backward and shifts left until the prefix is ordered.

Insertion Sort Complete Info Card

Online AlgorithmAdaptive

Insertion Sort builds the final sorted array one element at a time by repeatedly taking the next element and inserting it into its correct position within the sorted portion.

Algorithm Characteristics

Time Complexity (Best)

When array is already sorted

O(n)

Time Complexity (Average)

Typical case with random data

O(n²)

Time Complexity (Worst)

When array is reverse sorted

O(n²)

Space Complexity

In-place sorting algorithm

O(1)

Stable

Maintains relative order of equal elements

Yes

Adaptive

Efficient for nearly-sorted data

Yes

Sorting Process Steps

Start with second element as key

Compare key with sorted elements to its left

Shift elements greater than key right

Insert key in correct position

Repeat for all elements

Early termination in sorted portions

Comparison with Other O(n²) Sorts

Algorithm	Swaps (Worst Case)	Best Case
Bubble Sort	O(n²)	O(n)
Selection Sort	O(n)	O(n²)
Insertion Sort	O(n²)	O(n)

Optimal Use Cases

•Small datasets (n ≤ 50)
•Nearly-sorted data (adaptive)
•Online sorting (data arriving sequentially)

When to Avoid

•Large random datasets
•Performance-critical applications
•When memory is not constrained (consider Merge Sort)

Pro Tip: Insertion Sort is often used as the base case in hybrid sorts (like Timsort) for small subarrays.

AdaptiveStableIn-place