Ordenar vector de strings numéricas en orden ascendente

Dado un vector de strings numéricas arr[] , la tarea es ordenar el vector dado de strings numéricas en orden ascendente.

Ejemplos:

Entrada: arr[] = {“120000”, “2”, “33”}
Salida: {“2”, “33”, “120000”}

Entrada: arr[] = {“120”, “2”, “3”}
Salida: {“2”, “3”, “120”}

Enfoque: La función sort() en C++  STL es capaz de ordenar el vector de strings si y solo si contiene un solo carácter numérico, por ejemplo, { ‘1’, ‘ ‘} pero para ordenar el vector numérico de string con múltiples caracteres, por ejemplo, {’12’, ’56’, ’14’ } uno debe escribir su propio comparador dentro de la función sort(). La función de comparación para ordenar en lógica de orden ascendente es la siguiente:

Construyamos una función de comparación considerando los dos casos que se dan a continuación:

• Caso 1: si la longitud de la string no es la misma, coloque una string de menor longitud en primer lugar, por ejemplo, {’12’, ‘2’} coloque ‘2’ antes de ’12’ ya que ‘2’ es más pequeño que ‘ 12’.
• Caso 2: si la longitud es la misma, coloque la string que sea numéricamente más pequeña, por ejemplo, ‘1’, ‘2’ coloque ‘1’ antes de ‘2’.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// 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 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 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# 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.

<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>

2 4 6 10 12 12 99

Complejidad de tiempo: O(N*log N)
Espacio auxiliar: O(1)