Comment trier les grands nombres stockés dans un tableau de chaînes?

Vous n'avez pas de tableau de nombres, vous avez un tableau de chaînes. Ils sont donc triés par ordre alphanumérique.

Une option serait d'utiliser la classe BigInteger pour les stocker sous forme de nombres:

string[] unsorted = { 
    "00000000000000000000000000001",
    "00000000000000000000000000002",
    "00000000000000000000000000100",
    "12303479849857341718340192371",
    "00000000000003084193741082937",
    "00000000000003084193741082938",
    "00000000000000000000000000111",
    "00000000000000000000000000200"
};

À défaut, si vous souhaitez les conserver comme les chaînes, vous pouvez les compléter avec des zéros pour rendre les longueurs cohérentes afin que le tri alphanumérique fonctionne:

BigInteger[] unsorted = { 
    BigInteger.Parse("1"),
    BigInteger.Parse("2"), 
    BigInteger.Parse("100"),
    BigInteger.Parse("12303479849857341718340192371"),
    BigInteger.Parse("3084193741082937"),
    BigInteger.Parse("3084193741082938"),
    BigInteger.Parse("111"),
    BigInteger.Parse("200")
};

Si vous choisissez le premier, changez simplement les types dans votre si bloque également BigInteger .

Essayez de suivre:

string[] unsorted = { "1","2","100","12303479849857341718340192371",
                      "3084193741082937","3084193741082938","111","200" };

var groups = unsorted.OrderBy(x => x.Length).GroupBy(x => x.Length).ToArray();
List<string> results = new List<string>();
foreach (var group in groups)
{
    string[] numbers = group.ToArray();
    for(int i = 0; i < numbers.Count() - 1; i++)
    {
        for(int j = i + 1; j < numbers.Count(); j++)
        {
            if(numbers[i].CompareTo(numbers[j]) == 1)
            {
                string temp = numbers[i];
                numbers[i] = numbers[j];
                numbers[j] = temp;
            }
        }
    }
    results.AddRange(numbers);
}

Si nous voulons trier de très gros nombres stockés sous forme de chaînes, sans changer la chaîne en BigInteger , il vaut mieux les trier en fonction de sa longueur au début, puis selon l'ordre lexicographique. Nous pouvons voir l'exemple de code ci-dessous:

using System;
using System.Linq;
public class Test
{
   public static void Main()
   {
     string[] unsorted = { "1","2", "100","12303479849857341718340192371",
                       "3084193741082937","3084193741082938","111","200" };

      unsorted.OrderBy(s => s.Length).ThenBy(s => s);
      Console.WriteLine("Sorted numbers are:");
      foreach (var x in unsorted) {
           Console.WriteLine(x);
      }
   }
}

Remarque: pour utiliser les fonctionnalités OrderBy et ThenBy , nous devons inclure en utilisant System.Linq dans notre programme.

Pour une solution élégante, vous pouvez utiliser linq , vous aurez un minimum de code avec de bonnes performances.

var result = unsorted.Select(e => decimal.Parse(e)).OrderBy(e => e);

Le système doit être comme suit. Vous pouvez transférer les valeurs du tableau vers une arraylist, puis les analyser toutes en BigInteger par boucle for. Et enfin vous pouvez trier la liste:

BigInteger[] unsorted; 
var bigIntegers = new List<System.Numerics.BigInteger>();

  for (int index = 0; index < unsorted.Length - 1; index++)
  {
  bigIntegers[i] = BigInteger.Parse[i]
  }

bigIntegers.sort();

Une autre variante:

    static void Main(string[] args)
    {
        List<string> unsorted = new List<string>(new string[] {"1","2","100","12303479849857341718340192371",
                        "3084193741082938","3084193741082937", "111","200" });

        unsorted.Sort((x, y) => (x.Length != y.Length ? x.Length.CompareTo(y.Length) : x.CompareTo(y)));

        foreach(string number in unsorted)
        {
            Console.WriteLine(number);
        }
        Console.Write("Press Enter to quit");
        Console.ReadLine();
    }

S'appuyant sur la réponse de @ jdweng , mais en la réduisant davantage en éliminant le tri à bulles "manuel":

using System.Collections.Generic;
using System.Linq;

...

string[] result =
    unsorted.OrderBy(x => x, Comparer<string>.Create((a, b) => a.Length == b.Length ? a.CompareTo(b) : a.Length - b.Length))
    .GroupBy(x => x.Length)
    .SelectMany(x => x)
    .ToArray();

Ou une autre variante du même thème:

string[] result =
    unsorted.OrderBy(x => x.Length)
    .GroupBy(x => x.Length)
    .SelectMany(x => x.OrderBy(y => y))
    .ToArray();

(Comme indiqué par le commentaire de @ fester sous la réponse de @ jdweng, cette approche ne fonctionnera pas de manière fiable si certaines des chaînes sont des nombres avec des zéros préfixés, comme " 00123 " par exemple.)

Vous pouvez utiliser BigInteger.Parse et utilisez le OrderBy de Linq dessus. Par exemple:

var sorted = unsorted.Select(BigInteger.Parse).OrderBy(e => e).Select(e => e.ToString()).ToArray();

Si vous en avez besoin en tant que chaîne:

var sorted = unsorted.Select(BigInteger.Parse).OrderBy(e => e).ToArray();

Cela a un inconvénient à le convertir d'abord en BigInteger , mais vous en avez probablement besoin de toute façon. Cependant, comparé à l'accès aux E / S et à la base de données, ce rien n'ajoute aux performances d'une application typique.

• Pro: lisible
• Contra: probablement pas la solution la plus efficace.