Add Insertion Sort

Author: imazizbohra

src/Main.java

@@ -7,7 +7,7 @@ public class Main {
     public static void main(String[] args) {
         int[] arr = {5, 3, 4, 2, 1};
 
-        SortingService.sort(arr, SortingAlgorithms.SELECTION_SORT);
+        SortingService.sort(arr, SortingAlgorithms.INSERTION_SORT);
 
         System.out.println(Arrays.toString(arr));
     }

src/sort/SortingService.java

@@ -1,6 +1,7 @@
 package sort;
 
 import sort.bubble.BubbleSort;
+import sort.insertion.InsertionSort;
 import sort.selection.SelectionSort;
 
 public class SortingService {
@@ -16,6 +17,9 @@ public static void sort(int[] arr, SortingAlgorithms sortAlgorithms) {
             case SELECTION_SORT:
                 SelectionSort.sort(arr);
                 break;
+            case INSERTION_SORT:
+                InsertionSort.sort(arr);
+                break;
         }
     }
 }

src/sort/bubble/README.md

@@ -9,9 +9,9 @@ Starting from the beginning of the list, compare the next pair. Swap their posit
 ### Time Complexity
 
 ---
-1. Worst Case: O(n<sup>2</sup>). The worst case occurs when we want to sort a list in ascending order, but it is arranged in descending order.
-2. Best Case: O(n). The average case is when the list is arranged in a jumbled order.
-3. Average Case: O(n). The best case occurs when the list is already arranged in the desired order.
+1. **Worst Case: O(n<sup>2</sup>).** The worst case occurs when we want to sort a list in ascending order, but it is arranged in descending order.
+2. **Best Case: O(n).** The average case is when the list is arranged in a jumbled order.
+3. **Average Case: O(n).** The best case occurs when the list is already arranged in the desired order.
 
 ### Space Complexity
 

src/sort/insertion/InsertionSort.java

@@ -0,0 +1,28 @@
+package sort.insertion;
+
+public class InsertionSort {
+    public static void sort(int[] arr) {
+        int n = arr.length;
+
+        // loop to select each element
+        // first element is already sorted
+        for (int i = 1; i < n; i++) {
+            // element to be moved to its correct place
+            int key = arr[i];
+            // comparison starts from the left adjacent element of key till zero
+            int j = i - 1;
+
+            // go backward until you find element > key
+            // stop as soon as you find element < key
+            while (j >= 0 && arr[j] > key) {
+                // shift greater elements to the right
+                arr[j + 1] = arr[j];
+                j--;
+            }
+
+            // index of smaller element than key + 1
+            // is the correct place for key
+            arr[j + 1] = key;
+        }
+    }
+}

src/sort/insertion/README.MD

@@ -0,0 +1,35 @@
+# Insertion Sort
+*Move element to its correct place to the left*
+
+### How It Works
+![Insertion Sort](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif)
+
+The partial sorted list (black) initially contains only the first element in the list. With each iteration one element (red) is removed from the "not yet checked for order" input data and inserted in-place into the sorted list.
+
+### Time Complexity
+
+---
+1. **Worst Case Complexity: O(n<sup>2</sup>)**
+Suppose, an array is in ascending order, and you want to sort it in descending order. In this case, worst case complexity occurs.
+Each element has to be compared with each of the other elements so, for every nth element, (n-1) number of comparisons are made.
+Thus, the total number of comparisons = n*(n-1) ~ n2
+2. **Best Case Complexity: O(n)**
+When the array is already sorted, the outer loop runs for n number of times whereas the inner loop does not run at all. So, there are only n number of comparisons. Thus, complexity is linear.
+3. **Average Case Complexity: O(n<sup>2</sup>)**
+It occurs when the elements of an array are in jumbled order (neither ascending nor descending).
+
+
+### Space Complexity
+
+---
+1. Space complexity is O(1) because an extra variable key is used.
+
+### Properties
+1. Comparison Based
+2. Not Stable
+3. Inplace
+4. Used in practise for small arrays (TimSort & IntroSort)
+
+### Insertion Sort Applications
+1. The array has a small number of elements
+2. There are only a few elements left to be sorted

src/sort/selection/README.MD

@@ -11,11 +11,11 @@
 ### Time Complexity
 
 ---
-1. Worst Case Complexity: O(n<sup>2</sup>)
+1. **Worst Case Complexity: O(n<sup>2</sup>)**
 If we want to sort in ascending order and the array is in descending order then, the worst case occurs.
-2. Best Case Complexity: O(n<sup>2</sup>)
+2. **Best Case Complexity: O(n<sup>2</sup>)**
 It occurs when the array is already sorted
-3. Average Case Complexity: O(n<sup>2</sup>)
+3. **Average Case Complexity: O(n<sup>2</sup>)**
 It occurs when the elements of the array are in jumbled order (neither ascending nor descending).