## 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]
```