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

src/sort/SortingAlgorithms.java

@@ -3,5 +3,6 @@
 public enum SortingAlgorithms {
     BUBBLE_SORT,
     SELECTION_SORT,
-    INSERTION_SORT
+    INSERTION_SORT,
+    CYCLE_SORT
 }

src/sort/SortingService.java

@@ -1,6 +1,7 @@
 package sort;
 
 import sort.bubble.BubbleSort;
+import sort.cycle.CycleSort;
 import sort.insertion.InsertionSort;
 import sort.selection.SelectionSort;
 
@@ -20,6 +21,9 @@ public static void sort(int[] arr, SortingAlgorithms sortAlgorithms) {
             case INSERTION_SORT:
                 InsertionSort.sort(arr);
                 break;
+            case CYCLE_SORT:
+                CycleSort.sort(arr);
+                break;
         }
     }
 }

src/sort/cycle/CycleSort.java

@@ -0,0 +1,56 @@
+package sort.cycle;
+
+public class CycleSort {
+    public static void sort(int[] arr) {
+        int n = arr.length;
+
+        // loop to start a cycle from each element
+        for (int cs = 0; cs < n; cs++) {
+            int item = arr[cs];
+            int pos = cs;
+
+            // count no of the smallest element from this position
+            for (int j = cs + 1; j < n; j++) {
+                if (arr[j] < item)
+                    pos++;
+            }
+
+            // if pos == cs means element is already at correct place
+            if (pos == cs)
+                continue;
+
+            // ignore duplicates
+            while (item == arr[pos])
+                pos++;
+
+            // swap if smaller elements are found
+            if (pos != cs) {
+                int temp = arr[pos];
+                arr[pos] = item;
+                item = temp;
+            }
+
+            while (pos != cs) {
+                pos = cs;
+
+                // count no of the smallest element from this position
+                for (int j = cs + 1; j < n; j++) {
+                    if (arr[j] < item)
+                        pos++;
+                }
+
+                // ignore duplicates
+                while (item == arr[pos])
+                    pos++;
+
+                // swap if smaller elements are found
+                if (item != arr[pos]) {
+                    int temp = arr[pos];
+                    arr[pos] = item;
+                    item = temp;
+                }
+            }
+        }
+    }
+}
+

src/sort/cycle/README.MD

@@ -0,0 +1,43 @@
+# Cycle Sort
+*In each cycle the smallest element will be moved to its correct place to the left*
+
+### How It Works: [Link to Video](https://www.youtube.com/watch?v=vJn71L7CPH4)
+
+
+### 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. The space complexity is constant cause this algorithm is in place so it does not use any extra memory to sort.
+
+### Properties
+1. Comparison Based
+2. Not Stable
+3. Inplace
+4. Makes min memory writes as compare to all other sorting algorithms
+
+### Cycle Sort Applications
+1. This sorting algorithm is best suited for situations where memory write or swap operations are costly.
+2. Useful for complex problems.
+
+
+### Advantages
+1. No additional storage is required.
+2. In-Place sorting algorithm.
+3. A minimum number of writes to the memory
+4. Cycle sort is useful when the array is stored in EEPROM or FLASH.
+
+### Disadvantages
+1. It is not mostly used.
+2. It has more time complexity O(n<sup>2</sup>)
+3. Unstable sorting algorithm.