Cycle Sort - GeeksforGeeks

25 Mar, 2021
Cycle sort is an in-place sorting Algorithm, unstable sorting algorithm, a comparison sort that is theoretically optimal in terms of the total number of writes to the original array.  
It is optimal in terms of number of memory writes. It minimizes the number of memory writes to sort (Each value is either written zero times, if it’s already in its correct position, or written one time to its correct position.)
It is based on the idea that array to be sorted can be divided into cycles. Cycles can be visualized as a graph. We have n nodes and an edge directed from node i to node j if the element at i-th index must be present at j-th index in the sorted array. Cycle in arr[] = {2, 4, 5, 1, 3}  
Cycle in arr[] = {4, 3, 2, 1}  
 
We one by one consider all cycles. We first consider the cycle that includes first element. We find correct position of first element, place it at its correct position, say j. We consider old value of arr[j] and find its correct position, we keep doing this till all elements of current cycle are placed at correct position, i.e., we don’t come back to cycle starting point. 
Explanation :  
 arr[] = {10, 5, 2, 3}
 index =  0   1   2   3
cycle_start = 0 
item = 10 = arr[0]

Find position where we put the item  
pos = cycle_start
i=pos+1
while(i<n)
if (arr[i] < item)  
    pos++;

We put 10 at arr[3] and change item to 
old value of arr[3].
arr[] = {10, 5, 2, 10} 
item = 3 

Again rotate rest cycle that start with index '0' 
Find position where we put the item = 3 
we swap item with element at arr[1] now 
arr[] = {10, 3, 2, 10} 
item = 5

Again rotate rest cycle that start with index '0' and item = 5 
we swap item with element at arr[2].
arr[] = {10, 3, 5, 10 } 
item = 2

Again rotate rest cycle that start with index '0' and item = 2
arr[] = {2, 3,  5, 10}  

Above is one iteration for cycle_stat = 0.
Repeat above steps for cycle_start = 1, 2, ..n-2
 
CPP
Java
Python3
C#
Javascript
// C++ program to implement cycle sort#include <iostream>using namespace std; // Function sort the array using Cycle sortvoid cycleSort(int arr[], int n){    // count number of memory writes    int writes = 0;     // traverse array elements and put it to on    // the right place    for (int cycle_start = 0; cycle_start <= n - 2; cycle_start++) {        // initialize item as starting point        int item = arr[cycle_start];         // Find position where we put the item. We basically        // count all smaller elements on right side of item.        int pos = cycle_start;        for (int i = cycle_start + 1; i < n; i++)            if (arr[i] < item)                pos++;         // If item is already in correct position        if (pos == cycle_start)            continue;         // ignore all duplicate  elements        while (item == arr[pos])            pos += 1;         // put the item to it's right position        if (pos != cycle_start) {            swap(item, arr[pos]);            writes++;        }         // Rotate rest of the cycle        while (pos != cycle_start) {            pos = cycle_start;             // Find position where we put the element            for (int i = cycle_start + 1; i < n; i++)                if (arr[i] < item)                    pos += 1;             // ignore all duplicate  elements            while (item == arr[pos])                pos += 1;             // put the item to it's right position            if (item != arr[pos]) {                swap(item, arr[pos]);                writes++;            }        }    }     // Number of memory writes or swaps    // cout << writes << endl ;} // Driver program to test above functionint main(){    int arr[] = { 1, 8, 3, 9, 10, 10, 2, 4 };    int n = sizeof(arr) / sizeof(arr[0]);    cycleSort(arr, n);     cout << "After sort : " << endl;    for (int i = 0; i < n; i++)        cout << arr[i] << " ";    return 0;}
// Java program to implement cycle sort import java.util.*;import java.lang.*; class GFG {    // Function sort the array using Cycle sort    public static void cycleSort(int arr[], int n)    {        // count number of memory writes        int writes = 0;         // traverse array elements and put it to on        // the right place        for (int cycle_start = 0; cycle_start <= n - 2; cycle_start++) {            // initialize item as starting point            int item = arr[cycle_start];             // Find position where we put the item. We basically            // count all smaller elements on right side of item.            int pos = cycle_start;            for (int i = cycle_start + 1; i < n; i++)                if (arr[i] < item)                    pos++;             // If item is already in correct position            if (pos == cycle_start)                continue;             // ignore all duplicate elements            while (item == arr[pos])                pos += 1;             // put the item to it's right position            if (pos != cycle_start) {                int temp = item;                item = arr[pos];                arr[pos] = temp;                writes++;            }             // Rotate rest of the cycle            while (pos != cycle_start) {                pos = cycle_start;                 // Find position where we put the element                for (int i = cycle_start + 1; i < n; i++)                    if (arr[i] < item)                        pos += 1;                 // ignore all duplicate elements                while (item == arr[pos])                    pos += 1;                 // put the item to it's right position                if (item != arr[pos]) {                    int temp = item;                    item = arr[pos];                    arr[pos] = temp;                    writes++;                }            }        }    }     // Driver program to test above function    public static void main(String[] args)    {        int arr[] = { 1, 8, 3, 9, 10, 10, 2, 4 };        int n = arr.length;        cycleSort(arr, n);         System.out.println("After sort : ");        for (int i = 0; i < n; i++)            System.out.print(arr[i] + " ");    }} // Code Contributed by Mohit Gupta_OMG <(0_o)>
# Python program to implement cycle sort def cycleSort(array):  writes = 0     # Loop through the array to find cycles to rotate.  for cycleStart in range(0, len(array) - 1):    item = array[cycleStart]         # Find where to put the item.    pos = cycleStart    for i in range(cycleStart + 1, len(array)):      if array[i] < item:        pos += 1         # If the item is already there, this is not a cycle.    if pos == cycleStart:      continue         # Otherwise, put the item there or right after any duplicates.    while item == array[pos]:      pos += 1    array[pos], item = item, array[pos]    writes += 1         # Rotate the rest of the cycle.    while pos != cycleStart:             # Find where to put the item.      pos = cycleStart      for i in range(cycleStart + 1, len(array)):        if array[i] < item:          pos += 1             # Put the item there or right after any duplicates.      while item == array[pos]:        pos += 1      array[pos], item = item, array[pos]      writes += 1     return writes   # driver codearr = [1, 8, 3, 9, 10, 10, 2, 4 ]n = len(arr)cycleSort(arr) print("After sort : ")for i in range(0, n) :    print(arr[i], end = ' ') # Code Contributed by Mohit Gupta_OMG <(0_o)>
// C# program to implement cycle sortusing System; class GFG {         // Function sort the array using Cycle sort    public static void cycleSort(int[] arr, int n)    {        // count number of memory writes        int writes = 0;         // traverse array elements and        // put it to on the right place        for (int cycle_start = 0; cycle_start <= n - 2; cycle_start++)        {            // initialize item as starting point            int item = arr[cycle_start];             // Find position where we put the item.            // We basically count all smaller elements            // on right side of item.            int pos = cycle_start;            for (int i = cycle_start + 1; i < n; i++)                if (arr[i] < item)                    pos++;             // If item is already in correct position            if (pos == cycle_start)                continue;             // ignore all duplicate elements            while (item == arr[pos])                pos += 1;             // put the item to it's right position            if (pos != cycle_start) {                int temp = item;                item = arr[pos];                arr[pos] = temp;                writes++;            }             // Rotate rest of the cycle            while (pos != cycle_start) {                pos = cycle_start;                 // Find position where we put the element                for (int i = cycle_start + 1; i < n; i++)                    if (arr[i] < item)                        pos += 1;                 // ignore all duplicate elements                while (item == arr[pos])                    pos += 1;                 // put the item to it's right position                if (item != arr[pos]) {                    int temp = item;                    item = arr[pos];                    arr[pos] = temp;                    writes++;                }            }        }    }     // Driver program to test above function    public static void Main()    {        int[] arr = { 1, 8, 3, 9, 10, 10, 2, 4 };        int n = arr.Length;                 // Function calling        cycleSort(arr, n);         Console.Write("After sort : ");        for (int i = 0; i < n; i++)            Console.Write(arr[i] + " ");    }} // This code is contributed by Nitin Mittal
<script>// Javascript program to implement cycle sort     // Function sort the array using Cycle sort    function cycleSort(arr, n)    {             // count number of memory writes        let writes = 0;           // traverse array elements and put it to on        // the right place        for (let cycle_start = 0; cycle_start <= n - 2; cycle_start++)        {                     // initialize item as starting point            let item = arr[cycle_start];               // Find position where we put the item. We basically            // count all smaller elements on right side of item.            let pos = cycle_start;            for (let i = cycle_start + 1; i < n; i++)                if (arr[i] < item)                    pos++;               // If item is already in correct position            if (pos == cycle_start)                continue;               // ignore all duplicate elements            while (item == arr[pos])                pos += 1;               // put the item to it's right position            if (pos != cycle_start)            {                let temp = item;                item = arr[pos];                arr[pos] = temp;                writes++;            }               // Rotate rest of the cycle            while (pos != cycle_start)            {                pos = cycle_start;                   // Find position where we put the element                for (let i = cycle_start + 1; i < n; i++)                    if (arr[i] < item)                        pos += 1;                   // ignore all duplicate elements                while (item == arr[pos])                    pos += 1;                   // put the item to it's right position                if (item != arr[pos]) {                    let temp = item;                    item = arr[pos];                    arr[pos] = temp;                    writes++;                }            }        }    }      // Driver code        let arr = [ 1, 8, 3, 9, 10, 10, 2, 4 ];       let n = arr.length;       cycleSort(arr, n);        document.write("After sort : " + "<br/>");       for (let i = 0; i < n; i++)           document.write(arr[i] + " ");     // This code is contributed by susmitakundugoaldanga.</script>
Output:  
After sort : 
1 2 3 4 8 9 10 10 
Time Complexity : O(n2) Worst Case : O(n2) Average Case: O(n2) Best Case : O(n2)This sorting algorithm is best suited for situations where memory write or swap operations are costly.  
YouTubeGeeksforGeeks500K subscribersCycle Sort | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 2:27•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=gZNOM_yMdSQ" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Reference: https://en.wikipedia.org/wiki/Cycle_sortThis article is contributed by Nishant Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
nitin mittal
rahul sholapurkar
pedastrian
susmitakundugoaldanga
Sorting
Sorting
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Time Complexities of all Sorting Algorithms
Radix Sort
Merge two sorted arrays
Sort an array of 0s, 1s and 2s
Count Inversions in an array | Set 1 (Using Merge Sort)
k largest(or smallest) elements in an array
sort() in Python
Merge Sort for Linked Lists
Python List sort() method
Python Program for QuickSort