Open In App
Related Articles

# Strand Sort

Strand sort is a recursive sorting algorithm that sorts items of a list into increasing order. It has O(n²) worst time complexity which occurs when the input list is reverse sorted. It has a best case time complexity of O(n) which occurs when the input is a list that is already sorted.

Given a list of items, sort them in increasing order.

Examples:

Input: ip[] = {10, 5, 30, 40, 2, 4, 9}
Output: op[] = {2, 4, 5, 9, 10, 30, 40}

Input: ip[] = {1, 10, 7}
Output: op[] = {1, 7, 10}

Illustrations:

Let, input[] = {10, 5, 30, 40, 2, 4, 9}

Initialize: output[] = {}, sublist[] = {}

Move first item of input to sublist.
sublist[] = {10}

Traverse remaining items of input and if current element is greater than last item of sublist, move this item from input to sublist.
Now, sublist[] = {10, 30, 40}, input[] = {5, 2, 4, 9}

Merge sublist into output.
op = {10, 30, 40}

Next recursive call: Move first item of input to sublist. sublist[] = {5}

Traverse remaining items of input and move elements greater than last inserted.
input[] = {2, 4}
sublist[] = {5, 9}

Merge sublist into op.
output = {5, 9, 10, 30, 40}

Last Recursive Call:

{2, 4} are first moved to sublist and then merged into output.
output = {2, 4, 5, 9, 10, 30, 40}

Below are simple steps used in the algorithm:

• Let ip[] be input list and op[] be output list.
• Create an empty sublist and move first item of ip[] to it.
• Traverse remaining items of ip. For every item x, check if x is greater than last inserted item to sublist. If yes, remove x from ip and add at the end of sublist. If no, ignore x (Keep it in ip)
• Merge sublist into op (output list)
• Recur for remaining items in ip and current items in op.

Below is the implementation of above algorithm in C++ and Javascript. The C++ implementation uses list in C++ STL

## CPP

 `// CPP program to implement Strand Sort``#include ``using` `namespace` `std;` `// A recursive function to implement Strand``// sort.``// ip is input list of items (unsorted).``// op is output list of items (sorted)``void` `strandSort(list<``int``> &ip, list<``int``> &op)``{``    ``// Base case : input is empty``    ``if` `(ip.empty())``        ``return``;` `    ``// Create a sorted sublist with``    ``// first item of input list as``    ``// first item of the sublist``    ``list<``int``> sublist;``    ``sublist.push_back(ip.front());``    ``ip.pop_front();``     ` `    ``// Traverse remaining items of ip list``    ``for` `(``auto` `it = ip.begin(); it != ip.end(); ) {` `        ``// If current item of input list``        ``// is greater than last added item``        ``// to sublist, move current item``        ``// to sublist as sorted order is``        ``// maintained.``        ``if` `(*it > sublist.back()) {``            ``sublist.push_back(*it);` `            ``// erase() on list removes an``            ``// item and returns iterator to``            ``// next of removed item.``            ``it = ip.erase(it);``        ``}` `        ``// Otherwise ignore current element``        ``else``            ``it++;``    ``}` `    ``// Merge current sublist into output``    ``op.merge(sublist);` `    ``// Recur for remaining items in``    ``// input and current items in op.``    ``strandSort(ip, op);``}` `// Driver code``int` `main(``void``)``{``    ``list<``int``> ip{10, 5, 30, 40, 2, 4, 9};` `    ``// To store sorted output list``    ``list<``int``> op;` `    ``// Sorting the list``    ``strandSort(ip, op);` `    ``// Printing the sorted list``    ``for` `(``auto` `x : op)``        ``cout << x << " ";``    ``return` `0;``}`

## Javascript

 `// Javascript program to implement Strand Sort` `// A recursive function to implement Strand sort.``// ip is input list of items (unsorted).``// op is output list of items (sorted)``function` `strandSort(ip)``{  ``    ``// Create a sorted sublist with``    ``// first item of input list as``    ``// first item of the sublist``    ``var` `sublist=[];``    ``sublist.push(ip[0]);``    ``ip.shift();``    ` `    ` `    ``// Traverse remaining items of ip list``    ``var` `len=ip.length-1;``//last index of input list``    ``var` `len2=sublist.length-1;``//last index of sublist``   ` `    ``var` `it =0;``     ``while``(it<=len){` `        ``// If current item of input list``        ``// is greater than last added item``        ``// to sublist, move current item``        ``// to sublist as sorted order is``        ``// maintained.``        ``if` `(ip[it] >sublist[len2]) {``            ``sublist.push(ip[it]);``            ``len2++;``           ` `            ``// splice(index,1) on list removes an``            ``// item and moves "it" to``            ``// next of removed item.``            ` `            ``ip.splice(it,1);``        ` `        ``}` `        ``// Otherwise ignore current element``        ``else``{``            ``it++;``        ``}``    ``}` `   ``// Merge current sublist into output``   ``while``(sublist.length>0 && op.length>0){``        ``if``(sublist[0]>=op[0]){opp.push(op.shift());}``        ``else``{opp.push(sublist.shift());}``    ``}``    ``if``(sublist.length==0){``        ``opp=[...opp,...op];``    ``}``    ``if``(op.length==0){``        ``opp=[...opp,...sublist];``    ``}``    ``op=[...opp];``    ``opp.length=0;``    ` `    ``// Recur for remaining items in input and current items in op.``    ``//Added base case``    ``if``(ip.length>0){``    ``strandSort(ip);``    ``}``}` `// Driver code` `    ``var` `ip=[10, 5, 30, 40, 2, 4, 9];` `    ``// To store sorted output list``    ``var` `op=[];``    ``//list helping in merge operation``    ``var` `opp=[];``    ``// Sorting the list``    ``strandSort(ip);``    ` `    ``// Printing the sorted list``        ``console.log(op);`

Output:

`2 4 5 9 10 30 40`

Time complexity: O(N2)
Auxiliary Space: O(N)

### Check out DSA Self Paced Course

More Sorting Algorithms :

Practice Problems on Sorting