Sort vector of Numeric Strings in ascending order

Last Updated : 02 Jun, 2022

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>