## Merge Sort Algorithm using Generics in Java

February 26th, 2014 No Comments »

Today, we are going to show the implementation of the Merge Sort algorithm, which is the fifth one from our series of tutorials on sorting algorithms. If you haven’t read the first four tutorials on BubbleSortInsertionSortSelectionSort and CountingSort, I strongly recommend that you go there and read them, 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 a MergeSort 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 sorted arrays.

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

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

System.out.println();

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(5);
sorter.sortAscending(values);
// sorter.sortDescending(values);
Utils.printArray(values);
}

private Sortable newSortable(int sortableAlgorithm) {
switch (sortableAlgorithm) {
case 1:
return new BubbleSort();
case 2:
return new InsertionSort();
case 3:
return new SelectionSort();
case 4:
return new CountingSort();
case 5:
return new MergeSort();
default:
return new BubbleSort();
}
}
}
```

## Counting Sort Algorithm in Java

February 20th, 2014 3 Comments »

Today, we are going to show the implementation of the Counting sort algorithm, which is the forth one from our series of tutorials on sorting algorithms. If you haven’t read the first three tutorials on BubbleSortInsertionSort and SelectionSort, I strongly recommend that you read them, 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 a CountingSort object and pass some Integer and String arrays to it, but unlike the other three algorithms that are able to sort any object that implements Comparable, this algorithm only works with Integers (positive and negative values), the arrays of String will be ignored. The last part of the code is to print the sorted arrays.

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

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

System.out.println();

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(4);
sorter.sortAscending(values);
// sorter.sortDescending(values);
Utils.printArray(values);
}

private Sortable newSortable(int sortableAlgorithm) {
switch (sortableAlgorithm) {
case 1:
return new BubbleSort();
case 2:
return new InsertionSort();
case 3:
return new SelectionSort();
case 4:
return new CountingSort();
default:
return new BubbleSort();
}
}
}
```

## Selection Sort Algorithm using Generics in Java

January 19th, 2014 2 Comments »

Today, we are going to show the implementation of the Selection Sort algorithm, which is the third one from our series of tutorials on sorting algorithms. If you haven’t read the first two tutorials on BubbleSort and InsertionSort, I strongly recommend that you go there and read them, 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 SelectionSort 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();
app.run();
}

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 });

System.out.println();

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(3);
sorter.sortAscending(values);
// sorter.sortDescending(values);
Utils.printArray(values);
}

private Sortable newSortable(int sortableAlgorithm) {
switch (sortableAlgorithm) {
case 1:
return new BubbleSort();
case 2:
return new InsertionSort();
case 3:
return new SelectionSort();
default:
return new BubbleSort();
}
}
}
```

## Insertion Sort Algorithm using Generics in Java

January 18th, 2014 3 Comments »

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();
app.run();
}

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 });

System.out.println();

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.sortAscending(values);
// sorter.sortDescending(values);
Utils.printArray(values);
}

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

## Bubble Sort Algorithm using Generics in Java

January 17th, 2014 4 Comments »

This is our first tutorial about sorting algorithms and we are going to start by showing the Bubble Sort. It gets its name from the way smaller elements “bubble” to the top of the list.

We will create other sorting algorithms, so the first thing we need to do is prepare the structure of classes and packages that we are going to use.

Every sorting algorithm that we are going to create will have at least 2 public methods, which are: sortAscending and sortDescending. To make sure this will always be true, we are going to create an Interface called Sortable.

```public interface Sortable {
<T extends Comparable<T>> void sortAscending(T[] values);
<T extends Comparable<T>> void sortDescending(T[] values);
}
```