Буквенно-цифровая сортировка с использованием LINQ

Question

У меня есть string[], в котором каждый элемент заканчивается некоторым числовым значением.

string[] partNumbers = new string[] 
{ 
    "ABC10", "ABC1","ABC2", "ABC11","ABC10", "AB1", "AB2", "Ab11" 
};

Я пытаюсь отсортировать вышеуказанный массив следующим образом, используя LINQ, но я не получаю ожидаемый результат.

var result = partNumbers.OrderBy(x => x);

Фактический результат:

AB1
Ab11
AB2
ABC1
ABC10
ABC10
ABC11
ABC2

Ожидаемый результат

AB1
AB2
AB11
..

Answer 1

Это связано с тем, что по умолчанию для строки используется стандартное алфавитно-числовое (лексикографическое) упорядочение, и ABC11 будет предшествовать ABC2, поскольку упорядочение всегда происходит слева направо.

Чтобы получить то, что вы хотите, вам нужно дополнить числовую часть в вашем заказе предложением, что-то вроде:

 var result = partNumbers.OrderBy(x => PadNumbers(x));

, где PadNumbers может быть определено как:

public static string PadNumbers(string input)
{
    return Regex.Replace(input, "[0-9]+", match => match.Value.PadLeft(10, '0'));
}

Это дополняет нулями любое число (или числа), которые появляются во входной строке, так что OrderBy видит:

ABC0000000010
ABC0000000001
...
AB0000000011

Заполнение происходит только для клавиши, используемой для сравнения. Исходные строки (без отступов) сохраняются в результате.

Обратите внимание, что в этом подходе предполагается максимальное количество цифр для чисел на входе.

Answer 2

Надлежащую реализацию буквенно-цифрового метода сортировки, который «просто работает», можно найти на сайте Дейва Кель . Версия C # находится здесь .

Answer 3

Если вы хотите отсортировать список объектов по определенному свойству с помощью LINQ и пользовательского компаратора, например, по Dave Koelle , вы должны сделать что-то вроде этого:

...

items = items.OrderBy(x => x.property, new AlphanumComparator()).ToList();

...

Вы также должны изменить класс Дейва для наследования от System.Collections.Generic.IComparer<object> вместо базового IComparer, чтобы сигнатура класса стала:

...

public class AlphanumComparator : System.Collections.Generic.IComparer<object>
{

    ...

Лично я предпочитаю реализацию James McCormack , потому что она реализует IDisposable, хотя мой сравнительный анализ показывает, что она немного медленнее.

Answer 4

Вы можете использовать PInvoke, чтобы получить быстрый и хороший результат:

class AlphanumericComparer : IComparer<string>
{
    [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
    static extern int StrCmpLogicalW(string s1, string s2);

    public int Compare(string x, string y) => StrCmpLogicalW(x, y);
}

Вы можете использовать его как AlphanumComparatorFast из ответа выше.

Answer 5

public class AlphanumComparatorFast : IComparer
{
    List<string> GetList(string s1)
    {
        List<string> SB1 = new List<string>();
        string st1, st2, st3;
        st1 = "";
        bool flag = char.IsDigit(s1[0]);
        foreach (char c in s1)
        {
            if (flag != char.IsDigit(c) || c=='\'')
            {
                if(st1!="")
                SB1.Add(st1);
                st1 = "";
                flag = char.IsDigit(c);
            }
            if (char.IsDigit(c))
            {
                st1 += c;
            }
            if (char.IsLetter(c))
            {
                st1 += c;
            }


        }
        SB1.Add(st1);
        return SB1;
    }



    public int Compare(object x, object y)
    {
        string s1 = x as string;
        if (s1 == null)
        {
            return 0;
        }
        string s2 = y as string;
        if (s2 == null)
        {
            return 0;
        }
        if (s1 == s2)
        {
            return 0;
        }
        int len1 = s1.Length;
        int len2 = s2.Length;
        int marker1 = 0;
        int marker2 = 0;

        // Walk through two the strings with two markers.
        List<string> str1 = GetList(s1);
        List<string> str2 = GetList(s2);
        while (str1.Count != str2.Count)
        {
            if (str1.Count < str2.Count)
            {
                str1.Add("");
            }
            else
            {
                str2.Add("");
            }
        }
        int x1 = 0; int res = 0; int x2 = 0; string y2 = "";
        bool status = false;
        string y1 = ""; bool s1Status = false; bool s2Status = false;
        //s1status ==false then string ele int;
        //s2status ==false then string ele int;
        int result = 0;
        for (int i = 0; i < str1.Count && i < str2.Count; i++)
        {
            status = int.TryParse(str1[i].ToString(), out res);
            if (res == 0)
            {
                y1 = str1[i].ToString();
                s1Status = false;
            }
            else
            {
                x1 = Convert.ToInt32(str1[i].ToString());
                s1Status = true;
            }

            status = int.TryParse(str2[i].ToString(), out res);
            if (res == 0)
            {
                y2 = str2[i].ToString();
                s2Status = false;
            }
            else
            {
                x2 = Convert.ToInt32(str2[i].ToString());
                s2Status = true;
            }
            //checking --the data comparision
            if(!s2Status && !s1Status )    //both are strings
            {
                result = str1[i].CompareTo(str2[i]);
            }
            else if (s2Status && s1Status) //both are intergers
            {
                if (x1 == x2)
                {
                    if (str1[i].ToString().Length < str2[i].ToString().Length)
                    {
                        result = 1;
                    }
                    else if (str1[i].ToString().Length > str2[i].ToString().Length)
                        result = -1;
                    else
                        result = 0;
                }
                else
                {
                    int st1ZeroCount=str1[i].ToString().Trim().Length- str1[i].ToString().TrimStart(new char[]{'0'}).Length;
                    int st2ZeroCount = str2[i].ToString().Trim().Length - str2[i].ToString().TrimStart(new char[] { '0' }).Length;
                    if (st1ZeroCount > st2ZeroCount)
                        result = -1;
                    else if (st1ZeroCount < st2ZeroCount)
                        result = 1;
                    else
                    result = x1.CompareTo(x2);

                }
            }
            else
            {
                result = str1[i].CompareTo(str2[i]);
            }
            if (result == 0)
            {
                continue;
            }
            else
                break;

        }
        return result;
    }
}

ИСПОЛЬЗОВАНИЕ этого класса:

    List<string> marks = new List<string>();
                marks.Add("M'00Z1");
                marks.Add("M'0A27");
                marks.Add("M'00Z0");
marks.Add("0000A27");
                marks.Add("100Z0");

    string[] Markings = marks.ToArray();

                Array.Sort(Markings, new AlphanumComparatorFast());

Answer 6

Вы можете PInvoke до StrCmpLogicalW (функция Windows), чтобы сделать это.Смотрите здесь: Порядок естественной сортировки в C #

Answer 7

Нет естественного способа сделать это в .NET, , но посмотрите этот пост в блоге о естественной сортировке

Вы можете поместить это в метод расширения и использовать его вместо OrderBy

Answer 8

Похоже, что он выполняет лексикографическое упорядочение независимо от маленьких или прописных букв.

Вы можете попробовать использовать для этого несколько пользовательских выражений в этой лямбде.

Answer 9

Поскольку число символов в начале является переменным, поможет регулярное выражение:

var re = new  Regex(@"\d+$"); // finds the consecutive digits at the end of the string
var result = partNumbers.OrderBy(x => int.Parse(re.Match(x).Value));

Если бы существовало фиксированное количество префиксных символов, то для извлечения можно использовать метод Substringначиная с соответствующих символов:

// parses the string as a number starting from the 5th character
var result = partNumbers.OrderBy(x => int.Parse(x.Substring(4)));

Если числа могут содержать десятичный разделитель или разделитель тысяч, то регулярное выражение также должно разрешать эти символы:

var re = new Regex(@"[\d,]*\.?\d+$");
var result = partNumbers.OrderBy(x => double.Parse(x.Substring(4)));

ЕслиСтрока, возвращаемая регулярным выражением или Substring, может быть не разобрана int.Parse / double.Parse, затем используйте соответствующий вариант TryParse:

var re = new  Regex(@"\d+$"); // finds the consecutive digits at the end of the string
var result = partNumbers.OrderBy(x => {
    int? parsed = null;
    if (int.TryParse(re.Match(x).Value, out var temp)) {
        parsed = temp;
    }
    return parsed;
});

Answer 10

Я не знаю, как это сделать в LINQ, но, возможно, вам нравится этот способ:

Array.Sort(partNumbers, new AlphanumComparatorFast());

// Показать результаты

foreach (string h in partNumbers )
{
Console.WriteLine(h);
}