Порядок буквенно-цифровой строки численно, а затем по префиксу / суффиксу

Question

У меня сложный шаблон сортировки для репликации, и моё решение кажется несколько затрудненным.Мои данные представляют собой список чисел, которые могут содержать несколько букв в качестве суффикса, а префикс - только буквы («aaa», «aab», «ac» и т. Д.).Мне нужно отсортировать численно, затем отсортировать по суффиксу (если он есть), а затем по префиксу (если он есть).

Например,

"a1a",
"5ac",
"1",
"12",
"2",
"11",
"5aa",
"3",
"5ab",
"a2b",
"abb11ca",
"1b",
"aba11ca"

будет отсортировано как

1
a1a
1b
2
a2b
3
5aa
5ab
5ac
11
aba11ca
abb11ca
12

Вот решение, которое я придумал, используя Linq.

static void Main(string[] args)
{
    var arr = new []
    {"b2","a1a","5ac","1","12","2","11","5aa","3","5ab","a1","a2b","abb11ca","1b","aba11ca"
    };
    var ordered = arr.Select(str => {
                var parts = SplitIntoPrefixNumberSuffix(str);
                var number = int.Parse(parts[1]);
                return new { str, parts, number };
            })
            .OrderBy(x => x.number).ThenBy(x => x.parts[2]).ThenBy(x => x.parts[0])
            .Select(x => x.str);

    Console.WriteLine("sorted array: ");
    foreach (var s in ordered)
    {
        Console.WriteLine("{0}", s);
    }

    Console.ReadLine();
}      

public static string[] SplitIntoPrefixNumberSuffix(string str)
{
    var numChar = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    var numLoc = str.IndexOfAny(numChar);
    var nums = "";
    foreach (var c in str)
    {
        if (char.IsDigit(c))
            nums = nums + c;
    }
    Console.WriteLine("numLoc: {0}; nums: {1}", numLoc, nums.Count());
    var prefix = str.Substring(0, numLoc);
    var suffix = str.Substring(numLoc + nums.Count());
    Console.WriteLine("prefix {0}; nums {1}; suffix {2}", prefix, nums, suffix);
    return new[] { prefix, nums, suffix };
}

Вот .netfiddle из него работает: https://dotnetfiddle.net/C7ZA0b.

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

Я никогда раньше не писал Comparable;Я посмотрел на Алфавитно-цифровая сортировка Dot Net Pearls и могу следить за ним, но недостаточно хорошо, чтобы изменить его в соответствии со своими потребностями.

Есть ли какой-нибудь IComparable, который я могу использовать для выполнения вышеуказанной работы?Любые предложения о хорошем месте, чтобы узнать, как написать один?

Answer 1

Как альтернатива моему существующему ответу, я недавно написал помощник ComparerBuilder<T>, который делает хороший клиентский код.

Теперь вы можете:

var comparer = new ComparerBuilder<string>()
    .SortKey(k => int.Parse(Regex.Match(k, @"\d+").Value))
        .ThenKey(k => Regex.Match(k, @"\D*$").Value)
        .ThenKey(k => Regex.Match(k, @"^\D*").Value)
        .Build();

var ordered = data.OrderBy(x => x, comparer);

Answer 2

Вот реализация IComparer буквенно-цифровых символов Дейв Коэль .

Редактировать: Добавление образца кода.

void Main()
{
    var arr = new[] {"b2","a1a","5ac","1","12","2","11","5aa","3","5ab","a1","a2b","abb11ca","1b","aba11ca" };

    var items = arr.OrderBy(x => x.ToString(), new AlphanumComparator()).ToList();

    Console.WriteLine("sorted array: ");
    foreach (var s in items)
    {
        Console.WriteLine("{0}", s);
    }
}

public class AlphanumComparator : IComparer<object>
{
    private enum ChunkType { Alphanumeric, Numeric };
    private bool InChunk(char ch, char otherCh)
    {
        ChunkType type = ChunkType.Alphanumeric;

        if (char.IsDigit(otherCh))
        {
            type = ChunkType.Numeric;
        }

        if ((type == ChunkType.Alphanumeric && char.IsDigit(ch))
            || (type == ChunkType.Numeric && !char.IsDigit(ch)))
        {
            return false;
        }

        return true;
    }

    public int Compare(object x, object y)
    {
        String s1 = x as string;
        String s2 = y as string;
        if (s1 == null || s2 == null)
        {
            return 0;
        }

        int thisMarker = 0, thisNumericChunk = 0;
        int thatMarker = 0, thatNumericChunk = 0;

        while ((thisMarker < s1.Length) || (thatMarker < s2.Length))
        {
            if (thisMarker >= s1.Length)
            {
                return -1;
            }
            else if (thatMarker >= s2.Length)
            {
                return 1;
            }
            char thisCh = s1[thisMarker];
            char thatCh = s2[thatMarker];

            StringBuilder thisChunk = new StringBuilder();
            StringBuilder thatChunk = new StringBuilder();

            while ((thisMarker < s1.Length) && (thisChunk.Length == 0 || InChunk(thisCh, thisChunk[0])))
            {
                thisChunk.Append(thisCh);
                thisMarker++;

                if (thisMarker < s1.Length)
                {
                    thisCh = s1[thisMarker];
                }
            }

            while ((thatMarker < s2.Length) && (thatChunk.Length == 0 || InChunk(thatCh, thatChunk[0])))
            {
                thatChunk.Append(thatCh);
                thatMarker++;

                if (thatMarker < s2.Length)
                {
                    thatCh = s2[thatMarker];
                }
            }

            int result = 0;
            // If both chunks contain numeric characters, sort them numerically
            if (char.IsDigit(thisChunk[0]) && char.IsDigit(thatChunk[0]))
            {
                thisNumericChunk = Convert.ToInt32(thisChunk.ToString());
                thatNumericChunk = Convert.ToInt32(thatChunk.ToString());

                if (thisNumericChunk < thatNumericChunk)
                {
                    result = -1;
                }

                if (thisNumericChunk > thatNumericChunk)
                {
                    result = 1;
                }
            }
            else
            {
                result = thisChunk.ToString().CompareTo(thatChunk.ToString());
            }

            if (result != 0)
            {
                return result;
            }
        }

        return 0;
    }
}

Answer 3

В качестве опции вы можете реализовать свой собственный Custom Comparer

public class CustomStringComparer : IComparer<string>
{
    public int Compare(string first, string second)
    {
        var compareByCore = CompareCore(first, second);
        var compareBySuffix = CompareSuffix(first, second);
        var compareByPrefix = ComparePrefix(first, second);

        return compareByCore != 0 ? compareByCore 
            : compareBySuffix != 0 ? compareBySuffix
            : compareByPrefix;
    }

    private int CompareCore(string a, string b)
    {
        var firstCoreNumber = Regex.Match(a, @"\d+").Value;
        var secondCoreNumber = Regex.Match(b, @"\d+").Value;

        if (!string.IsNullOrEmpty(firstCoreNumber) && !string.IsNullOrEmpty(secondCoreNumber))
        {
            return int.Parse(firstCoreNumber).CompareTo(int.Parse(secondCoreNumber));
        }

        return 0;
    }

    private int CompareSuffix(string a, string b)
    {
        var firstSuffix = Regex.Match(a, @"\D+$").Value;
        var secondSuffix = Regex.Match(b, @"\D+$").Value;

        return firstSuffix.CompareTo(secondSuffix);
    }

    private int ComparePrefix(string a, string b)
    {
        var firstPrefix = Regex.Match(a, @"^\D+").Value;
        var secondPrefix = Regex.Match(b, @"^\D+").Value;

        return firstPrefix.CompareTo(secondPrefix);
    }
}

А когда вы вызываете метод заказа, просто отправьте экземпляр этого сравнителя:

var arr = new[]
        { "a1a", "5ac", "1", "12", "2", "11", "5aa", "3", "5ab", "a2b", "abb11ca", "1b", "aba11ca" };

    var sortedArr = arr.OrderBy(x => x, new CustomStringComparer());

    foreach (var s in sortedArr)
    {
        Console.Write($"{s} ");
    }

Answer 4

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

var regex = new Regex(@"^(?<pre>\D*)(?<num>\d+)(?<suff>\D*)$");
var ordered = data.Select(d => (match: regex.Match(d), value: d))
    .Where(x => x.match.Success) //throw away anything that doesn't conform
    .Select(x => (
        x.value, 
        pre: x.match.Groups["pre"].Value, 
        num: int.Parse(x.match.Groups["num"].Value), 
        suff: x.match.Groups["suff"].Value))
    .OrderBy(x => x.num)
    .ThenBy(x => x.suff)
    .ThenBy(x => x.pre)
    .Select(x => x.value);

... но, в конечном счете, это не так уж отличается от вашего решения.Я не могу понять, как специализированный IComparer упростит это.

Если у вас нет доступных кортежей (

data.Select(d => new { match = regex.Match(d), value = d})
    .Where(x => x.match.Success)
    .Select(x => new { 
        x.value, 
        pre = x.match.Groups["pre"].Value, 
        num = int.Parse(x.match.Groups["num"].Value), 
        suff = x.match.Groups["suff"].Value})
    .OrderBy(x => x.num)
    .ThenBy(x => x.suff)
    .ThenBy(x => x.pre)
    .Select(x => x.value)