Sort vector of Numeric Strings in ascending order

Given a vector of numeric strings arr[], the task is to sort the given vector of numeric strings in ascending order.

Examples:

Input: arr[] = {“120000”, “2”, “33”}
Output: {“2”, “33”, “120000”}

Input: arr[] = {“120”, “2”, “3”}
Output: {“2”, “3”, “120”}

Approach: The sort() function in C++ STL is able to sort vector of strings if and only if it contains single numeric character for example, { ‘1’, ‘ ‘}  but to sort numeric vector of string with multiple character for example, {’12’, ’56’, ’14’ } one should write own comparator inside sort() function. The comparator function to sort in ascending order logic goes as:

Let’s build a comparator function considering the two cases given below:

• Case 1: If the length of the string is not the same then place a smaller length string in first place for example, {’12’, ‘2’}  place ‘2’ before ’12’ as ‘2’ is smaller than ’12’.
• Case 2: If length is the same then place the string which is numerically smaller for example, ‘1’, ‘2’ place ‘1’ before ‘2’.

Below is the C++ program to implement the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Comparator Function
bool myCmp(string s1, string s2)
{

    // If size of numeric strings
    // are same the put lowest value
    // first
    if (s1.size() == s2.size()) {
        return s1 < s2;
    }

    // If size is not same put the
    // numeric string with less
    // number of digits first
    else {
        return s1.size() < s2.size();
    }
}

// Driver Code
int main()
{
    vector<string> v
        = { "12", "2", "10", "6", "4", "99", "12" };

    // Calling sort function with
    // custom comparator
    sort(v.begin(), v.end(), myCmp);

    // Print the vector values after
    // sorting
    for (auto it : v) {
        cout << it << " ";
    }

    cout << "\n";
}

Java

// Java program for the above approach
import java.util.*;
class GFG{

// Comparator Function
static List<String> sort(List<String> list)
{
    Comparator<String> cmp = (o1, o2) -> {
        // If size of numeric Strings
        // are same the put lowest value
        // first
        if (o1.length() == o2.length()) {
            return Integer.valueOf(o1)-Integer.valueOf(o2);
        }

        // If size is not same put the
        // numeric String with less
        // number of digits first
        else {
            return o1.length()-o2.length();
        }
    };
    Collections.sort(list, cmp);
    return list;
}

// Driver Code
public static void main(String[] args)
{
    List<String> v
        = Arrays.asList( "12", "2", "10", "6", "4", "99", "12" );

    // Calling sort function with
    // custom comparator
    v = sort(v);

    // Print the vector values after
    // sorting
    for (String it : v) {
        System.out.print(it+ " ");
    }

}
}

// This code is contributed by 29AjayKumar

Python3

# Python3 Program to implement
# the above approach

# Comparator Function
from functools import cmp_to_key

def myCmp(s1, s2):

    # If size of numeric strings
    # are same the put lowest value
    # first
    if (len(s1) == len(s2)):
        return int(s1) - int(s2)

    # If size is not same put the
    # numeric string with less
   # number of digits first
    else:
        return len(s1) - len(s2)

# Driver Code
v = ["12", "2", "10", "6", "4", "99", "12"]

# Calling sort function with
# custom comparator
v.sort(key = cmp_to_key(myCmp))

# Print the vector values after
# sorting
for i in range(len(v)) :
    print(v[i],end=" ")

# This code is contributed by shinjanpatra

C#

// C# program for the above approach
using System;

class GFG
{

  // Comparator Function
  public static int myCmp(string s1, string s2)
  {

    // If size of numeric strings
    // are same the put lowest value
    // first
    if (s1.Length == s2.Length) {
      return Convert.ToInt32(s1) - Convert.ToInt32(s2);
    }

    // If size is not same put the
    // numeric string with less
    // number of digits first
    else {
      return s1.Length-s2.Length;
    }
  }

  // Driver code
  public static void Main()
  {
    string[] v = { "12", "2", "10", "6", "4", "99", "12" };

    // Calling sort function with
    // custom comparator
    Array.Sort<string>(
      v, delegate(string m, string n) { return myCmp(m,n); });

    // Print the vector values after
    // sorting
    for (int i = 0; i < v.Length; i++)
    {
      Console.Write(v[i]+" ");
    }

  }
}

// This code is contributed by Pushpesh Raj.

Javascript

<script>
        // JavaScript Program to implement
        // the above approach

        // Comparator Function
        function myCmp(s1, s2) {

            // If size of numeric strings
            // are same the put lowest value
            // first
            if (s1.length == s2.length) {
                return parseInt(s1) - parseInt(s2);
            }

            // If size is not same put the
            // numeric string with less
            // number of digits first
            else {
                return s1.length - s2.length;
            }
        }

        // Driver Code

        let v
            = ["12", "2", "10", "6", "4", "99", "12"];

        // Calling sort function with
        // custom comparator
        v.sort(myCmp)

        // Print the vector values after
        // sorting
        for (let i = 0; i < v.length; i++) {
            document.write(v[i] + " ")
        }

// This code is contributed by Potta Lokesh
    </script>

Output:

2 4 6 10 12 12 99

Time Complexity: O(N*log N)
Auxiliary Space: O(1)