Add selection 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.BUBBLE_SORT);
+        SortingService.sort(arr, SortingAlgorithms.SELECTION_SORT);
 
         System.out.println(Arrays.toString(arr));
     }

src/sort/SortingService.java

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

src/sort/bubble/README.md

@@ -1,11 +1,12 @@
 # Bubble Sort
+*Largest element will be bubbled to the last in every pass*
 
 ### 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/selection/README.MD

@@ -0,0 +1,40 @@
+# Selection Sort
+*Select the minimum element and move it to its correct place in every pass*
+
+### Time Complexity
+
+---
+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>)
+It occurs when the array is already sorted
+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).
+
+
+### Space Complexity
+
+---
+1. Space complexity is O(1) because an extra variable is used for swapping.
+
+### Properties
+1. Comparison Based
+2. Not Stable
+3. Inplace
+4. Basic idea for Heap Sort
+5. Less memory writes compared to Bubble Sort
+
+### Selection Sort Applications
+1. It is used when a small list is to be sorted
+2. If cost of swapping does not matter
+3. If checking of all the elements is compulsory
+4. If cost of writing to a memory matters like in flash memory (number of writes/swaps is O(n) as compared to O(n<sup>2</sup>) of bubble sort)
+
+### Advantages
+1. Simple and easy to understand.
+2. Works well with small datasets.
+
+### Disadvantages
+1. Selection sort has a time complexity of O(n<sup>2</sup>) in the worst and average case.
+2. Does not work well on large datasets.
+3. Does not preserve the relative order of items with equal keys which means it is not stable.

src/sort/selection/SelectionSort.java

@@ -0,0 +1,26 @@
+package sort.selection;
+
+public class SelectionSort {
+    public static void sort(int[] arr) {
+        int n = arr.length;
+
+        // loop for (n-1) passes
+        for (int i = 0; i < n; i++) {
+            // assume this is the index of min element
+            int min_index = i;
+
+            // loop to find min element in remaining elements
+            for (int j = i + 1; j < n; j++) {
+                // compare and find index of min element < assumed arr[min_index]
+                if (arr[j] < arr[min_index]) {
+                    min_index = j;
+                }
+            }
+
+            // swap elements to put min element to its correct position
+            int temp = arr[i];
+            arr[i] = arr[min_index];
+            arr[min_index] = temp;
+        }
+    }
+}