Insertion Sort Algorithm using Generics in Java

Today, we are going to show the implementation of the Insertion Sort, which is the second algorithm of our series of tutorials on sorting algorithms. If you haven’t read the first tutorial on BubbleSort, I strongly recommend that you go there and read it, because we will reuse code that was explained there.

The application is really simple, it will just get an instance of a Sortable algorithm, which in this case will be an InsertionSort object and pass some Integer and String arrays to it, but any object that implements Comparable can be passed as a parameter as well, then it will print the elements from the arrays.

public class SorterApp {
  public static void main(String[] args) {
    SorterApp app = new SorterApp();;

  private void run() {
    sort(new Integer[] { 1, 2, 3, 4, 5 });
    sort(new Integer[] { 3, 1, 5, 4, 2 });
    sort(new Integer[] { 5, 4, 3, 2, 1 });


    sort(new String[] { "a", "b", "c", "d", "e" });
    sort(new String[] { "c", "a", "e", "d", "b" });
    sort(new String[] { "e", "d", "c", "b", "a" });

  private <T extends Comparable<T>> void sort(T[] values) {
    Sortable sorter = newSortable(2);
    // sorter.sortDescending(values);

  private Sortable newSortable(int sortableAlgorithm) {
    switch (sortableAlgorithm) {
      case 1:
        return new BubbleSort();
      case 2:
        return new InsertionSort();
        return new BubbleSort();

You can see on the code below that the sortAscending and sortDescending invoke the same method sort with the difference of just 2 parameters. This is done because the code to sort in ascending or descending order is pretty much the same, the difference is just one small detail.

The Sorter Abstract class and the Sortable Interface were explained on the previous tutorial.

public class InsertionSort extends Sorter implements Sortable {
  public <T extends Comparable<T>> void sortAscending(T[] values) {
    sort(values, 0, 1);

  public <T extends Comparable<T>> void sortDescending(T[] values) {
    sort(values, 1, 0);

The Insertion sort builds the final sorted array one item at a time. It is not very efficient on large lists but it is easy to implement.

  private <T extends Comparable<T>> void sort(T[] values, int first, int second) {
    if ((null == values) || (values.length < 2)) {

    int length = values.length;
    int count = 0;
    int j;
    for (int i = 1; i < length; i++) {
      j = i;
      while ((j > 0) && (values[j - first].compareTo(values[j - second]) < 0)) {
        swap(values, j - first, j - second);
    System.out.printf("%2s: ", count);


Insertion Sort Results

You can download all the files here: InsertionSort.

Thank you for your time and feel free to leave any comments or questions.


3 thoughts on “Insertion Sort Algorithm using Generics in Java”

Leave a Reply

Your email address will not be published. Required fields are marked *

Time limit is exhausted. Please reload CAPTCHA.

This site uses Akismet to reduce spam. Learn how your comment data is processed.