Merge pull request #404 from KavinduDr/main

Create Cycle sort algorithm

Author: larymak

Data Structures and Algorithms/Sorting Algorithms/Cycle_Sort.py

@@ -0,0 +1,50 @@
+from typing import List
+
+def cycle_sort(nums: List[int]) -> int:
+
+    writes = 0
+
+    for cycle_start in range(len(nums) - 1):
+        current = nums[cycle_start]
+
+        # Find the target position for the current item.
+        target_position = cycle_start
+        for i in range(cycle_start + 1, len(nums)):
+            if nums[i] < current:
+                target_position += 1
+
+        # Skip if the item is already in the correct position.
+        if target_position == cycle_start:
+            continue
+
+        # Handle duplicates by finding the next available position.
+        while current == nums[target_position]:
+            target_position += 1
+
+        nums[target_position], current = current, nums[target_position]
+        writes += 1
+
+        # Rotate the rest of the cycle.
+        while target_position != cycle_start:
+            target_position = cycle_start
+            for i in range(cycle_start + 1, len(nums)):
+                if nums[i] < current:
+                    target_position += 1
+
+            while current == nums[target_position]:
+                target_position += 1
+
+            nums[target_position], current = current, nums[target_position]
+            writes += 1
+
+    return writes
+
+
+if __name__ == "__main__":
+    arr = [1, 8, 3, 9, 10, 10, 2, 4]
+    print("Before sort:", arr)
+
+    writes = cycle_sort(arr)
+
+    print("After sort:", arr)
+    print(f"Number of writes: {writes}")

Data Structures and Algorithms/Sorting Algorithms/README.md

@@ -0,0 +1,25 @@
+# Cycle Sort Algorithm
+
+## Overview
+Cycle Sort is a comparison-based sorting algorithm that is efficient when minimizing memory writes is important. It is an in-place sorting algorithm that rearranges the elements by identifying cycles in the permutation of elements.
+
+## Algorithm Explanation
+The algorithm works by:
+1. Identifying the correct position of each element in the array.
+2. Placing the element in its correct position and replacing the element already there in the cycle.
+3. Repeating the process for the remaining unsorted elements.
+
+## Complexity
+- **Time Complexity**:
+  - Best, Worst, and Average Case: O(n²) (due to nested cycles).
+- **Space Complexity**: O(1) (in-place sorting).
+
+## Usage Example
+```python
+from Cycle_Sort import cycle_sort
+
+arr = [4, 5, 3, 2, 1]
+print("Original array:", arr)
+writes = cycle_sort(arr)
+print("Sorted array:", arr)
+print("Number of writes performed:", writes)