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 <bits/stdc++.h>
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);