## Insertion Sort Implementation In Java – Working Code Example

Insertion Sort Animation. Image Credit: Wikipedia / Creative Commons

Algorithm:

• Take one element, compare with the one next to it and put in the order it belongs to, thus forming a partially sorted list.
• Iterate through the list, one item at a time until no input elements remain.

Pseudo code is given below:

```for i ← 1 to length(A)
j ← i
while j > 0 and A[j-1] > A[j]
swap A[j] and A[j-1]
j ← j - 1
```

Complexity:

• Best Case: O(n) – For already sorted list
• Average Case: O(n^2)
• Worst Case: O(n^2)

Notes / Usage:

• Insertion Sort is:
• Stable
• Takes O(1) extra space for swapping
• In-Place Sorting – No extra memory is required
• One real life usage of this kind of sorting is sorting a deck of cards.

Java Implementation Code:

```package com.icodejava.blog.datastructure;

import java.util.Arrays;

/**
* @author Kushal Paudyal
* www.icodejava.com
* Created On -  Feb 26, 2014
*/
public class InsertionSort {

public static void main(String args[]) {
int[] numberArray = { 5, 4, 7, 3, 3, 9, 0, 1, 2, 8, 6, -5 };

sort(numberArray);

}

public static void sort(int[] numberArray) {

System.out.println("Input Array: " + Arrays.toString(numberArray));

for (int i = 1; i < numberArray.length; i++) {
for (int j = i; j > 0; j--) {
// Start comparing data with adjacent one and swap if smaller
if (numberArray[j] < numberArray[j - 1]) {
swap(numberArray, j, j - 1);
}
}
}

System.out.println("Sorted Array: " + Arrays.toString(numberArray));

}

/**
* Swaps data from an array.
*/
private static void swap(int[] array, int firstIndex, int secondIndex) {
if (array == null || firstIndex < 0 || firstIndex > array.length
|| secondIndex < 0 || secondIndex > array.length) {
return;
}
int temp = array[firstIndex];
array[firstIndex] = array[secondIndex];
array[secondIndex] = temp;

}

}
```

Output of running above program:

```Input Array: [5, 4, 7, 3, 3, 9, 0, 1, 2, 8, 6, -5]
Sorted Array: [-5, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9]
```

## Selection Sort Implementation In Java – Working Code Example

Algorithm:

• First find the smallest element in the array and exchange it with the element in the first position.
• Then find the second smallest element and exchange it with the element in the second position.
• Continue in this way until the entire array is sorted.

Complexity:

• Best Case: n^2
• Average Case: n^2
• Worst Case: n^2

Notes:

• Selection sort is an in-place comparison sort – thus taking O(1) memory space.
• Selection sort is not stable**
• Selection sort is a very simple algorithm
• This sort is inefficient on large arrays.
• Useful if less data movement is required. Selection sort has the lowest data movement. Useful when writing to Flash Memory.

When to use Selection Sort?

• If the data is of small size
• If I/O operations are more (since Selection Sort only writes n number of times). Specially when the sorting is done on a file rather than in memory
• If simplicity is required rather than performance

**A sorting algorithm is said to be stable if two objects with equal keys appear in the same order in sorted output as they appear in the input unsorted array. Some sorting algorithms are stable by nature like Insertion sort, Merge Sort, Bubble Sort
Java Implementation:

```package com.icodejava.blog.datastructure;

import java.util.Arrays;

/**
* @author Kushal Paudyal
* www.icodejava.com
* Created On -  Feb 25, 2014
*/
public class SelectionSort {

public static void main(String args[]) {
int[] numberArray = { 5, 4, 7, 3, 3, 9, 0, 1, 2, 8, 6, -5 };

sort(numberArray);

}

public static void sort(int[] numberArray) {
System.out.println("Input Array: " + Arrays.toString(numberArray));
for (int i = 0; i < numberArray.length-1; i++) {
int minIndex = i;
for (int j = i+1; j < numberArray.length; j++) {
if (numberArray[j] < numberArray[minIndex]) {
minIndex = j;
}

}

if(minIndex != i) {
swap(numberArray, minIndex, i);
}

}

System.out.println("Sorted Array: " + Arrays.toString(numberArray));
}

/**
* Swaps data from an array.
*/
private static void swap(int[] array, int firstIndex, int secondIndex) {
if (array == null || firstIndex < 0 || firstIndex > array.length
|| secondIndex < 0 || secondIndex > array.length) {
return;
}
int temp = array[firstIndex];
array[firstIndex] = array[secondIndex];
array[secondIndex] = temp;

}
}
```

Here is the output of running above Selection Sort program:

```Input Array: [5, 4, 7, 3, 3, 9, 0, 1, 2, 8, 6, -5]
Sorted Array: [-5, 0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9]
```

## Quick Sort Implementation In Java – Working Sample Code Example

Quick Sort is a sorting technique which uses Divide and Conquer mechanism to do the sorting. The algorithm for Quick Sort which is also sometimes known with it’s alternative name of “Partition Exchange Sort” is given below:

Quick Sort Algorithm:

1. Pick an element from the list as Pivot, usually the middle one.
2. Re-arrange elements with elements smaller than pivot on one side and greater that pivot on the other side.
3. Recursively apply this to the smaller partition and larger partitions separately.

Algorithm Complexity:

• Best Case: nlogn
• Worst Case: n^2
• Average Case: nlogn

Java Implementation:

```package com.icodejava.blog.datastructure;

import java.util.Arrays;

/**
* @author Kushal Paudyal
* www.icodejava.com
* Created On -  Feb 24, 2014
*/
public class QuickSort {

public static void main(String args[]) {
int[] items = { 0, 5, -1, 2, 3, 9, 7, 12, 5, 4 };
sort(items);
}

public static void sort(int[] items) {
if (items == null || items.length <= 0) {
return;
}

System.out.println("Input Array: " + Arrays.toString(items));
quickSort(items, 0, items.length - 1);
System.out.println("Sorted Array: " + Arrays.toString(items));

}

/**
* Recursively apply quickSort - one for partition smaller than pivot -
* another for partition bigger than pivot
*/
public static void quickSort(int items[], int start, int end) {
if (start >= end) {
return;
}

int pivot = partition(items, start, end);

if (start < pivot - 1) {
quickSort(items, start, pivot - 1);
}

if (end > pivot) {

quickSort(items, pivot, end);
}

}

/**
* Reorganizes the given list so all elements less than the first are before
* it and all greater elements are after it.
*/
private static int partition(int[] items, int start, int end) {

int pivot = items[(start + end) / 2];
while (start <= end) {
while (items[start] < pivot) {
start++;
}
while (items[end] > pivot) {
end--;
}

if (start <= end) {
swap(items, start, end);
start++;
end--;
}
}
return start;

}

/**
* Swaps data from an array.
*/
private static void swap(int[] array, int firstIndex, int secondIndex) {
if (array == null || firstIndex < 0 || firstIndex > array.length
|| secondIndex < 0 || secondIndex > array.length) {
return;
}
int temp = array[firstIndex];
array[firstIndex] = array[secondIndex];
array[secondIndex] = temp;

}

}
```

The output of running above program is:

```Input Array: [0, 5, -1, 2, 3, 9, 7, 12, 5, 4]
Sorted Array: [-1, 0, 2, 3, 4, 5, 5, 7, 9, 12]
```