C#での自然な並べ替え順序


129

誰かが良いリソースを持っているFileInfoか、配列のC#で自然順序ソートのサンプルを提供していますか?私はIComparer自分の種類のインターフェイスを実装しています。

回答:


148

最も簡単な方法は、Windowsの組み込み関数をP / Invokeし、それを比較関数として使用することIComparerです。

[DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
private static extern int StrCmpLogicalW(string psz1, string psz2);

Michael Kaplanは、この機能がここでどのように機能するかを示すいくつかのと、Vistaをより直感的に機能させるために行われた変更を示しています。この関数のプラス面は、動作するWindowsのバージョンと同じ動作になることですが、これはWindowsのバージョン間で異なることを意味するため、これが問題であるかどうかを考慮する必要があります。

したがって、完全な実装は次のようになります。

[SuppressUnmanagedCodeSecurity]
internal static class SafeNativeMethods
{
    [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
    public static extern int StrCmpLogicalW(string psz1, string psz2);
}

public sealed class NaturalStringComparer : IComparer<string>
{
    public int Compare(string a, string b)
    {
        return SafeNativeMethods.StrCmpLogicalW(a, b);
    }
}

public sealed class NaturalFileInfoNameComparer : IComparer<FileInfo>
{
    public int Compare(FileInfo a, FileInfo b)
    {
        return SafeNativeMethods.StrCmpLogicalW(a.Name, b.Name);
    }
}

8
すばらしい答えです。警告:これはWin2000では機能しません。そのオペレーティングシステムでまだ何かを実行している少数の人々のためです。一方、同様の関数を作成するには、KaplanのブログとMSDNドキュメントの間に十分なヒントがあります。
Chris Charabaruk、2008年

9
これは移植性がなく、Win32でのみ機能しますが、Linux / MacOS / Silverlight / Windows Phone / Metroでは機能しません
linquize

20
@linquize-彼は.NETはMonoではなく、Linux / OSXは本当に問題ではないと述べました。Windows Phone / Metroは、この回答が投稿された2008年には存在しませんでした。また、Silverlightでファイル操作を行う頻度はどれくらいですか。したがって、OPにとって、そしておそらく他のほとんどの人々にとって、それは適切な答えでした。いずれにせよ、より良い答えを提供することは自由です。それがこのサイトの仕組みです。
グレッグブナ

6
これは、元の答えが間違っていたという意味ではありません。最新の情報を追加します
2012

2
参考までComparer<T>に、実装するのではなく継承する場合、代わりにそれを使用するAPIで使用するために、ジェネリックメソッドを呼び出す(非ジェネリック)インターフェースのIComparer<T>組み込み実装を取得IComparerします。これも基本的に無料です。「I」を削除してに変更public int Compare(...)するだけpublic override int Compare(...)です。同じのためにIEqualityComparer<T>EqualityComparer<T>
Joe Amenta

75

私がこれに追加すると思っただけです(私が見つけることができる最も簡潔な解決策で):

public static IOrderedEnumerable<T> OrderByAlphaNumeric<T>(this IEnumerable<T> source, Func<T, string> selector)
{
    int max = source
        .SelectMany(i => Regex.Matches(selector(i), @"\d+").Cast<Match>().Select(m => (int?)m.Value.Length))
        .Max() ?? 0;

    return source.OrderBy(i => Regex.Replace(selector(i), @"\d+", m => m.Value.PadLeft(max, '0')));
}

上記は、文字列内のすべての数字を、すべての文字列内のすべての数字の最大長になるように埋め込み、結果の文字列を使用してソートします。

int?)へのキャストは、数字のない文字列のコレクションを許可することです(.Max()空の列挙可能オブジェクトでがスローされますInvalidOperationException)。


1
+1最も簡潔であるだけでなく、私が見た中で最速でもあります。受け入れられた答えを除いて、私はマシンの依存関係のためにそれを使用できません。約35秒で400万を超える値をソートしました。
ジーンS

4
これは美しく、読むことは不可能です。Linqの利点は(少なくとも)最高の平均と最高のケースのパフォーマンスを意味すると思いますので、私はそれで行くと思います。明快さの欠如にもかかわらず。@Matthew Horsleyに感謝します
Ian Grainger 14年

1
これは非常に良いですが、特定の10進数にはバグがあります。私の例では、k8.11とk8.2の並べ替えでした。これを修正するために、次の正規表現を実装しました:\ d +([\。、] \ d)?
devzero 2016年

2
また、このコードm.Value.PadLeft(max、 '0')を埋め込むときは、2番目のグループ(小数点+小数)の長さを考慮する必要があります
devzero

3
.DefaultIfEmpty().Max()キャストする代わりに使用できると思いますint?。また、source.ToList()列挙型の再列挙を避けるためにaを実行する価値があります。
ティージェイ2018

30

既存の実装はどれも見栄えがよくなかったので、自分で作成しました。結果は、Windowsエクスプローラの最新バージョン(Windows 7/8)で使用されている並べ替えとほぼ同じです。私が見た唯一の違いは、1)Windowsは(たとえばXP)が任意の長さの数値を処理するために使用されていましたが、現在は19桁に制限されています-私は無制限です、2)Windowsは特定のUnicode数字のセットと一貫性のない結果を出します-私は動作します細かい(ただし、サロゲートペアからの数字を数値的に比較することはなく、Windowsも同様))、3)異なるセクションにある場合、非プライマリソートの重みの異なるタイプを区別できません(例: "e-1é"と " é1e- "-数字の前後のセクションには発音区別符号と句読点の重みの違いがあります)。

public static int CompareNatural(string strA, string strB) {
    return CompareNatural(strA, strB, CultureInfo.CurrentCulture, CompareOptions.IgnoreCase);
}

public static int CompareNatural(string strA, string strB, CultureInfo culture, CompareOptions options) {
    CompareInfo cmp = culture.CompareInfo;
    int iA = 0;
    int iB = 0;
    int softResult = 0;
    int softResultWeight = 0;
    while (iA < strA.Length && iB < strB.Length) {
        bool isDigitA = Char.IsDigit(strA[iA]);
        bool isDigitB = Char.IsDigit(strB[iB]);
        if (isDigitA != isDigitB) {
            return cmp.Compare(strA, iA, strB, iB, options);
        }
        else if (!isDigitA && !isDigitB) {
            int jA = iA + 1;
            int jB = iB + 1;
            while (jA < strA.Length && !Char.IsDigit(strA[jA])) jA++;
            while (jB < strB.Length && !Char.IsDigit(strB[jB])) jB++;
            int cmpResult = cmp.Compare(strA, iA, jA - iA, strB, iB, jB - iB, options);
            if (cmpResult != 0) {
                // Certain strings may be considered different due to "soft" differences that are
                // ignored if more significant differences follow, e.g. a hyphen only affects the
                // comparison if no other differences follow
                string sectionA = strA.Substring(iA, jA - iA);
                string sectionB = strB.Substring(iB, jB - iB);
                if (cmp.Compare(sectionA + "1", sectionB + "2", options) ==
                    cmp.Compare(sectionA + "2", sectionB + "1", options))
                {
                    return cmp.Compare(strA, iA, strB, iB, options);
                }
                else if (softResultWeight < 1) {
                    softResult = cmpResult;
                    softResultWeight = 1;
                }
            }
            iA = jA;
            iB = jB;
        }
        else {
            char zeroA = (char)(strA[iA] - (int)Char.GetNumericValue(strA[iA]));
            char zeroB = (char)(strB[iB] - (int)Char.GetNumericValue(strB[iB]));
            int jA = iA;
            int jB = iB;
            while (jA < strA.Length && strA[jA] == zeroA) jA++;
            while (jB < strB.Length && strB[jB] == zeroB) jB++;
            int resultIfSameLength = 0;
            do {
                isDigitA = jA < strA.Length && Char.IsDigit(strA[jA]);
                isDigitB = jB < strB.Length && Char.IsDigit(strB[jB]);
                int numA = isDigitA ? (int)Char.GetNumericValue(strA[jA]) : 0;
                int numB = isDigitB ? (int)Char.GetNumericValue(strB[jB]) : 0;
                if (isDigitA && (char)(strA[jA] - numA) != zeroA) isDigitA = false;
                if (isDigitB && (char)(strB[jB] - numB) != zeroB) isDigitB = false;
                if (isDigitA && isDigitB) {
                    if (numA != numB && resultIfSameLength == 0) {
                        resultIfSameLength = numA < numB ? -1 : 1;
                    }
                    jA++;
                    jB++;
                }
            }
            while (isDigitA && isDigitB);
            if (isDigitA != isDigitB) {
                // One number has more digits than the other (ignoring leading zeros) - the longer
                // number must be larger
                return isDigitA ? 1 : -1;
            }
            else if (resultIfSameLength != 0) {
                // Both numbers are the same length (ignoring leading zeros) and at least one of
                // the digits differed - the first difference determines the result
                return resultIfSameLength;
            }
            int lA = jA - iA;
            int lB = jB - iB;
            if (lA != lB) {
                // Both numbers are equivalent but one has more leading zeros
                return lA > lB ? -1 : 1;
            }
            else if (zeroA != zeroB && softResultWeight < 2) {
                softResult = cmp.Compare(strA, iA, 1, strB, iB, 1, options);
                softResultWeight = 2;
            }
            iA = jA;
            iB = jB;
        }
    }
    if (iA < strA.Length || iB < strB.Length) {
        return iA < strA.Length ? 1 : -1;
    }
    else if (softResult != 0) {
        return softResult;
    }
    return 0;
}

署名はComparison<string>デリゲートと一致します。

string[] files = Directory.GetFiles(@"C:\");
Array.Sort(files, CompareNatural);

以下は、次のように使用するラッパークラスですIComparer<string>

public class CustomComparer<T> : IComparer<T> {
    private Comparison<T> _comparison;

    public CustomComparer(Comparison<T> comparison) {
        _comparison = comparison;
    }

    public int Compare(T x, T y) {
        return _comparison(x, y);
    }
}

例:

string[] files = Directory.EnumerateFiles(@"C:\")
    .OrderBy(f => f, new CustomComparer<string>(CompareNatural))
    .ToArray();

テストに使用する適切なファイル名のセットを次に示します。

Func<string, string> expand = (s) => { int o; while ((o = s.IndexOf('\\')) != -1) { int p = o + 1;
    int z = 1; while (s[p] == '0') { z++; p++; } int c = Int32.Parse(s.Substring(p, z));
    s = s.Substring(0, o) + new string(s[o - 1], c) + s.Substring(p + z); } return s; };
string encodedFileNames =
    "KDEqLW4xMiotbjEzKjAwMDFcMDY2KjAwMlwwMTcqMDA5XDAxNyowMlwwMTcqMDlcMDE3KjEhKjEtISox" +
    "LWEqMS4yNT8xLjI1KjEuNT8xLjUqMSoxXDAxNyoxXDAxOCoxXDAxOSoxXDA2NioxXDA2NyoxYSoyXDAx" +
    "NyoyXDAxOCo5XDAxNyo5XDAxOCo5XDA2Nio9MSphMDAxdGVzdDAxKmEwMDF0ZXN0aW5nYTBcMzEqYTAw" +
    "Mj9hMDAyIGE/YTAwMiBhKmEwMDIqYTAwMmE/YTAwMmEqYTAxdGVzdGluZ2EwMDEqYTAxdnNmcyphMSph" +
    "MWEqYTF6KmEyKmIwMDAzcTYqYjAwM3E0KmIwM3E1KmMtZSpjZCpjZipmIDEqZipnP2cgMT9oLW4qaG8t" +
    "bipJKmljZS1jcmVhbT9pY2VjcmVhbT9pY2VjcmVhbS0/ajBcNDE/ajAwMWE/ajAxP2shKmsnKmstKmsx" +
    "KmthKmxpc3QqbTAwMDNhMDA1YSptMDAzYTAwMDVhKm0wMDNhMDA1Km0wMDNhMDA1YSpuMTIqbjEzKm8t" +
    "bjAxMypvLW4xMipvLW40P28tbjQhP28tbjR6P28tbjlhLWI1Km8tbjlhYjUqb24wMTMqb24xMipvbjQ/" +
    "b240IT9vbjR6P29uOWEtYjUqb245YWI1Km/CrW4wMTMqb8KtbjEyKnAwMCpwMDEqcDAxwr0hKnAwMcK9" +
    "KnAwMcK9YSpwMDHCvcK+KnAwMipwMMK9KnEtbjAxMypxLW4xMipxbjAxMypxbjEyKnItMDAhKnItMDAh" +
    "NSpyLTAwIe+8lSpyLTAwYSpyLe+8kFwxIS01KnIt77yQXDEhLe+8lSpyLe+8kFwxISpyLe+8kFwxITUq" +
    "ci3vvJBcMSHvvJUqci3vvJBcMWEqci3vvJBcMyE1KnIwMCEqcjAwLTUqcjAwLjUqcjAwNSpyMDBhKnIw" +
    "NSpyMDYqcjQqcjUqctmg2aYqctmkKnLZpSpy27Dbtipy27Qqctu1KnLfgN+GKnLfhCpy34UqcuClpuCl" +
    "rCpy4KWqKnLgpasqcuCnpuCnrCpy4KeqKnLgp6sqcuCppuCprCpy4KmqKnLgqasqcuCrpuCrrCpy4Kuq" +
    "KnLgq6sqcuCtpuCtrCpy4K2qKnLgrasqcuCvpuCvrCpy4K+qKnLgr6sqcuCxpuCxrCpy4LGqKnLgsasq" +
    "cuCzpuCzrCpy4LOqKnLgs6sqcuC1puC1rCpy4LWqKnLgtasqcuC5kOC5lipy4LmUKnLguZUqcuC7kOC7" +
    "lipy4LuUKnLgu5UqcuC8oOC8pipy4LykKnLgvKUqcuGBgOGBhipy4YGEKnLhgYUqcuGCkOGClipy4YKU" +
    "KnLhgpUqcuGfoOGfpipy4Z+kKnLhn6UqcuGgkOGglipy4aCUKnLhoJUqcuGlhuGljCpy4aWKKnLhpYsq" +
    "cuGnkOGnlipy4aeUKnLhp5UqcuGtkOGtlipy4a2UKnLhrZUqcuGusOGutipy4a60KnLhrrUqcuGxgOGx" +
    "hipy4bGEKnLhsYUqcuGxkOGxlipy4bGUKnLhsZUqcuqYoFwx6pilKnLqmKDqmKUqcuqYoOqYpipy6pik" +
    "KnLqmKUqcuqjkOqjlipy6qOUKnLqo5UqcuqkgOqkhipy6qSEKnLqpIUqcuqpkOqplipy6qmUKnLqqZUq" +
    "cvCQkqAqcvCQkqUqcvCdn5gqcvCdn50qcu+8kFwxISpy77yQXDEt77yVKnLvvJBcMS7vvJUqcu+8kFwx" +
    "YSpy77yQXDHqmKUqcu+8kFwx77yO77yVKnLvvJBcMe+8lSpy77yQ77yVKnLvvJDvvJYqcu+8lCpy77yV" +
    "KnNpKnPEsSp0ZXN02aIqdGVzdNmi2aAqdGVzdNmjKnVBZS0qdWFlKnViZS0qdUJlKnVjZS0xw6kqdWNl" +
    "McOpLSp1Y2Uxw6kqdWPDqS0xZSp1Y8OpMWUtKnVjw6kxZSp3ZWlhMSp3ZWlhMip3ZWlzczEqd2Vpc3My" +
    "KndlaXoxKndlaXoyKndlacOfMSp3ZWnDnzIqeSBhMyp5IGE0KnknYTMqeSdhNCp5K2EzKnkrYTQqeS1h" +
    "Myp5LWE0KnlhMyp5YTQqej96IDA1MD96IDIxP3ohMjE/ejIwP3oyMj96YTIxP3rCqTIxP1sxKl8xKsKt" +
    "bjEyKsKtbjEzKsSwKg==";
string[] fileNames = Encoding.UTF8.GetString(Convert.FromBase64String(encodedFileNames))
    .Replace("*", ".txt?").Split(new[] { "?" }, StringSplitOptions.RemoveEmptyEntries)
    .Select(n => expand(n)).ToArray();

数字セクションはセクションごとに比較する必要があります。つまり、「abc12b」は「abc123」よりも小さくなければなりません。
SOUser 2013

次のデータを試すことができます:public string [] filenames = {"-abc12.txt"、 " abc12.txt"、 "1abc_2.txt"、 "a0000012.txt"、 "a0000012c.txt"、 "a000012.txt" 、「a000012b.txt」、「a012.txt」、「a0000102.txt」、「abc1_2.txt」、「abc12 .txt」、「abc12b.txt」、「abc123.txt」、「abccde.txt」、「 b0000.txt "、" b00001.txt "、" b0001.txt "、" b001.txt "、" c0000.txt "、" c0000c.txt "、" c00001.txt "、" c000b.txt "、" d0。 20.2b.txt」、「d0.1000c.txt」、「d0.2000y.txt」、「d0.20000.2b.txt」、「
SOUser '21 / 02/21

@XichenLi良いテストケースをありがとう。Windowsエクスプローラーでこれらのファイルを並べ替えると、使用しているWindowsのバージョンに応じて異なる結果が得られます。私のコードでは、これらの名前をServer 2003(およびおそらくXP)と同じように並べ替えますが、Windows 8とは異なります。
JD

2
バグがあります。範囲外のインデックス
linquize 2013年

3
素晴らしい解決策!約10,000ファイルの通常のシナリオでベンチマークを行ったところ、Matthewの正規表現の例よりも高速で、StrCmpLogicalW()とほぼ同じパフォーマンスでした。上記のコードには、「while(strA [jA] == zeroA)jA ++;」というマイナーなバグがあります。そして「while(strB [jB] == zeroB)jB ++;」「while(jA <strA.Length && strA [jA] == zeroA)jA ++;」である必要があります。そして「while(jB <strB.Length && strB [jB] == zeroB)jB ++;」。それ以外の場合、ゼロのみを含む文字列は例外をスローします。
黒木2015

22

linq orderbyの純粋なC#ソリューション:

http://zootfroot.blogspot.com/2009/09/natural-sort-compare-with-linq-orderby.html

public class NaturalSortComparer<T> : IComparer<string>, IDisposable
{
    private bool isAscending;

    public NaturalSortComparer(bool inAscendingOrder = true)
    {
        this.isAscending = inAscendingOrder;
    }

    #region IComparer<string> Members

    public int Compare(string x, string y)
    {
        throw new NotImplementedException();
    }

    #endregion

    #region IComparer<string> Members

    int IComparer<string>.Compare(string x, string y)
    {
        if (x == y)
            return 0;

        string[] x1, y1;

        if (!table.TryGetValue(x, out x1))
        {
            x1 = Regex.Split(x.Replace(" ", ""), "([0-9]+)");
            table.Add(x, x1);
        }

        if (!table.TryGetValue(y, out y1))
        {
            y1 = Regex.Split(y.Replace(" ", ""), "([0-9]+)");
            table.Add(y, y1);
        }

        int returnVal;

        for (int i = 0; i < x1.Length && i < y1.Length; i++)
        {
            if (x1[i] != y1[i])
            {
                returnVal = PartCompare(x1[i], y1[i]);
                return isAscending ? returnVal : -returnVal;
            }
        }

        if (y1.Length > x1.Length)
        {
            returnVal = 1;
        }
        else if (x1.Length > y1.Length)
        { 
            returnVal = -1; 
        }
        else
        {
            returnVal = 0;
        }

        return isAscending ? returnVal : -returnVal;
    }

    private static int PartCompare(string left, string right)
    {
        int x, y;
        if (!int.TryParse(left, out x))
            return left.CompareTo(right);

        if (!int.TryParse(right, out y))
            return left.CompareTo(right);

        return x.CompareTo(y);
    }

    #endregion

    private Dictionary<string, string[]> table = new Dictionary<string, string[]>();

    public void Dispose()
    {
        table.Clear();
        table = null;
    }
}

2
そのコードは、最終的にはcodeproject.com/KB/recipes/NaturalComparer.aspx(LINQ指向ではない)からのものです。
mhenry1384 2010

2
このブログ投稿では、Pascal Ganayeではなく、IComparerのジャスティンジョーンズ(codeproject.com/KB/string/NaturalSortComparer.aspx)を使用しています。
James McCormack

1
細かいことに注意してください。このソリューションは、ウィンドウとは異なるスペースを無視し、以下のMatthew Horsleyのコードほど優れていません。そのため、たとえば、 'string01' 'string 01' 'string 02' 'string02'(醜く見える)を取得する可能性があります。スペースのストリッピングを削除すると、文字列が逆順になります。つまり、 'string01'が 'string 01'の前に来るため、許容できない場合があります。
マイケルパーカー

これは、「1 Smith Rd」、「10 Smith Rd」、「2 Smith Rd」などの住所で機能しました-自然にソートされます。はい!良いですね!
Piotr Kula 2015

ちなみに、Type引数<T>は完全に不要であることに気づきました(リンク先のページのコメントにも示されているようです)。
jv-dev

18

Matthews Horsleysの回答は、プログラムが実行されているウィンドウのバージョンに応じて動作を変更しない最速の方法です。ただし、正規表現を1回作成し、RegexOptions.Compiledを使用すると、さらに高速になります。また、必要に応じて大文字と小文字を無視できるように文字列比較子を挿入するオプションを追加し、読みやすさを少し改善しました。

    public static IEnumerable<T> OrderByNatural<T>(this IEnumerable<T> items, Func<T, string> selector, StringComparer stringComparer = null)
    {
        var regex = new Regex(@"\d+", RegexOptions.Compiled);

        int maxDigits = items
                      .SelectMany(i => regex.Matches(selector(i)).Cast<Match>().Select(digitChunk => (int?)digitChunk.Value.Length))
                      .Max() ?? 0;

        return items.OrderBy(i => regex.Replace(selector(i), match => match.Value.PadLeft(maxDigits, '0')), stringComparer ?? StringComparer.CurrentCulture);
    }

使用する

var sortedEmployees = employees.OrderByNatural(emp => emp.Name);

これは、デフォルトの.net文字列比較の300ミリ秒と比較して、100,000文字列のソートに450ミリ秒かかります-かなり高速です!


2
これは、上記を読む価値があります- 正規表現でのコンパイルと再利用
mungflesh

16

私の解決策:

void Main()
{
    new[] {"a4","a3","a2","a10","b5","b4","b400","1","C1d","c1d2"}.OrderBy(x => x, new NaturalStringComparer()).Dump();
}

public class NaturalStringComparer : IComparer<string>
{
    private static readonly Regex _re = new Regex(@"(?<=\D)(?=\d)|(?<=\d)(?=\D)", RegexOptions.Compiled);

    public int Compare(string x, string y)
    {
        x = x.ToLower();
        y = y.ToLower();
        if(string.Compare(x, 0, y, 0, Math.Min(x.Length, y.Length)) == 0)
        {
            if(x.Length == y.Length) return 0;
            return x.Length < y.Length ? -1 : 1;
        }
        var a = _re.Split(x);
        var b = _re.Split(y);
        int i = 0;
        while(true)
        {
            int r = PartCompare(a[i], b[i]);
            if(r != 0) return r;
            ++i;
        }
    }

    private static int PartCompare(string x, string y)
    {
        int a, b;
        if(int.TryParse(x, out a) && int.TryParse(y, out b))
            return a.CompareTo(b);
        return x.CompareTo(y);
    }
}

結果:

1
a2
a3
a4
a10
b4
b5
b400
C1d
c1d2

私はそれが好きです。理解しやすく、Linqを必要としません。

11

注意する必要があります-StrCmpLogicalWまたはそのようなものは厳密に推移的ではなかったことを読んだことを漠然と思い出し、比較関数がそのルールに違反すると、.NETの並べ替えメソッドがときどき無限ループに陥るのを観察しました。

推移比較では、a <bおよびb <cの場合、常にa <cであると報告されます。その基準を常に満たすわけではない自然なソート順の比較を行う関数が存在しますが、それがStrCmpLogicalWか他のものかを思い出せません。


この声明の証拠はありますか?探し回った後、それが本当であるという兆候は見つかりません。
mhenry1384 2010

1
StrCmpLogicalWでこれらの無限ループを経験しました。
2010


Visual Studioフィードバックアイテム236900は存在しなくなりましたが、問題を確認する最新のアイテムは次のとおりです。connect.microsoft.com/ VisualStudio / feedback / details / 774540 / また、 回避策CultureInfoプロパティがありますCompareInfo、そしてそれが返すオブジェクトはオブジェクトを提供できSortKeyます。次に、これらを比較して推移性を保証できます。
ジョナサンギルバート

9

これは、英数字の両方を含む文字列をソートするための私のコードです。

まず、この拡張メソッド:

public static IEnumerable<string> AlphanumericSort(this IEnumerable<string> me)
{
    return me.OrderBy(x => Regex.Replace(x, @"\d+", m => m.Value.PadLeft(50, '0')));
}

次に、次のようにコードの任意の場所で使用します。

List<string> test = new List<string>() { "The 1st", "The 12th", "The 2nd" };
test = test.AlphanumericSort();

どのように機能しますか?ゼロで置き換えることにより:

  Original  | Regex Replace |      The      |   Returned
    List    | Apply PadLeft |    Sorting    |     List
            |               |               |
 "The 1st"  |  "The 001st"  |  "The 001st"  |  "The 1st"
 "The 12th" |  "The 012th"  |  "The 002nd"  |  "The 2nd"
 "The 2nd"  |  "The 002nd"  |  "The 012th"  |  "The 12th"

倍数で動作します:

 Alphabetical Sorting | Alphanumeric Sorting
                      |
 "Page 21, Line 42"   | "Page 3, Line 7"
 "Page 21, Line 5"    | "Page 3, Line 32"
 "Page 3, Line 32"    | "Page 21, Line 5"
 "Page 3, Line 7"     | "Page 21, Line 42"

それがお役に立てば幸いです。


6

追加するグレッグブナの答え(私はそのために検索してきたので)あなたが使用できるのLINQからこれを使用する場合、OrderByかかることをIComparer。例えば:

var items = new List<MyItem>();

// fill items

var sorted = items.OrderBy(item => item.Name, new NaturalStringComparer());

2

P / Invokeを使用せず、実行中の割り当てを回避する比較的単純な例を次に示します。

internal sealed class NumericStringComparer : IComparer<string>
{
    public static NumericStringComparer Instance { get; } = new NumericStringComparer();

    public int Compare(string x, string y)
    {
        // sort nulls to the start
        if (x == null)
            return y == null ? 0 : -1;
        if (y == null)
            return 1;

        var ix = 0;
        var iy = 0;

        while (true)
        {
            // sort shorter strings to the start
            if (ix >= x.Length)
                return iy >= y.Length ? 0 : -1;
            if (iy >= y.Length)
                return 1;

            var cx = x[ix];
            var cy = y[iy];

            int result;
            if (char.IsDigit(cx) && char.IsDigit(cy))
                result = CompareInteger(x, y, ref ix, ref iy);
            else
                result = cx.CompareTo(y[iy]);

            if (result != 0)
                return result;

            ix++;
            iy++;
        }
    }

    private static int CompareInteger(string x, string y, ref int ix, ref int iy)
    {
        var lx = GetNumLength(x, ix);
        var ly = GetNumLength(y, iy);

        // shorter number first (note, doesn't handle leading zeroes)
        if (lx != ly)
            return lx.CompareTo(ly);

        for (var i = 0; i < lx; i++)
        {
            var result = x[ix++].CompareTo(y[iy++]);
            if (result != 0)
                return result;
        }

        return 0;
    }

    private static int GetNumLength(string s, int i)
    {
        var length = 0;
        while (i < s.Length && char.IsDigit(s[i++]))
            length++;
        return length;
    }
}

先行ゼロは無視されないため、の01後に続き2ます。

対応する単体テスト:

public class NumericStringComparerTests
{
    [Fact]
    public void OrdersCorrectly()
    {
        AssertEqual("", "");
        AssertEqual(null, null);
        AssertEqual("Hello", "Hello");
        AssertEqual("Hello123", "Hello123");
        AssertEqual("123", "123");
        AssertEqual("123Hello", "123Hello");

        AssertOrdered("", "Hello");
        AssertOrdered(null, "Hello");
        AssertOrdered("Hello", "Hello1");
        AssertOrdered("Hello123", "Hello124");
        AssertOrdered("Hello123", "Hello133");
        AssertOrdered("Hello123", "Hello223");
        AssertOrdered("123", "124");
        AssertOrdered("123", "133");
        AssertOrdered("123", "223");
        AssertOrdered("123", "1234");
        AssertOrdered("123", "2345");
        AssertOrdered("0", "1");
        AssertOrdered("123Hello", "124Hello");
        AssertOrdered("123Hello", "133Hello");
        AssertOrdered("123Hello", "223Hello");
        AssertOrdered("123Hello", "1234Hello");
    }

    private static void AssertEqual(string x, string y)
    {
        Assert.Equal(0, NumericStringComparer.Instance.Compare(x, y));
        Assert.Equal(0, NumericStringComparer.Instance.Compare(y, x));
    }

    private static void AssertOrdered(string x, string y)
    {
        Assert.Equal(-1, NumericStringComparer.Instance.Compare(x, y));
        Assert.Equal( 1, NumericStringComparer.Instance.Compare(y, x));
    }
}

2

私は実際にそれを拡張メソッドとして実装したStringComparerので、たとえば次のようにすることができます:

  • StringComparer.CurrentCulture.WithNaturalSort() または
  • StringComparer.OrdinalIgnoreCase.WithNaturalSort()

その結果は、IComparer<string>のようなすべての場所で使用することができOrderByOrderByDescendingThenByThenByDescendingSortedSet<string>、などそして、あなたはまだ簡単になど、大文字と小文字の区別、文化を、微調整することができます

実装はかなり簡単で、大きなシーケンスでも非常にうまく機能するはずです。


私はそれを小さなNuGetパッケージとして公開したので、次のようにすることができます:

Install-Package NaturalSort.Extension

XMLドキュメントコメントとテストスイートを含むコードは、NaturalSort.Extension GitHubリポジトリで入手できます


コード全体は次のとおりです(まだC#7を使用できない場合は、NuGetパッケージをインストールしてください)。

public static class StringComparerNaturalSortExtension
{
    public static IComparer<string> WithNaturalSort(this StringComparer stringComparer) => new NaturalSortComparer(stringComparer);

    private class NaturalSortComparer : IComparer<string>
    {
        public NaturalSortComparer(StringComparer stringComparer)
        {
            _stringComparer = stringComparer;
        }

        private readonly StringComparer _stringComparer;
        private static readonly Regex NumberSequenceRegex = new Regex(@"(\d+)", RegexOptions.Compiled | RegexOptions.CultureInvariant);
        private static string[] Tokenize(string s) => s == null ? new string[] { } : NumberSequenceRegex.Split(s);
        private static ulong ParseNumberOrZero(string s) => ulong.TryParse(s, NumberStyles.None, CultureInfo.InvariantCulture, out var result) ? result : 0;

        public int Compare(string s1, string s2)
        {
            var tokens1 = Tokenize(s1);
            var tokens2 = Tokenize(s2);

            var zipCompare = tokens1.Zip(tokens2, TokenCompare).FirstOrDefault(x => x != 0);
            if (zipCompare != 0)
                return zipCompare;

            var lengthCompare = tokens1.Length.CompareTo(tokens2.Length);
            return lengthCompare;
        }
        
        private int TokenCompare(string token1, string token2)
        {
            var number1 = ParseNumberOrZero(token1);
            var number2 = ParseNumberOrZero(token2);

            var numberCompare = number1.CompareTo(number2);
            if (numberCompare != 0)
                return numberCompare;

            var stringCompare = _stringComparer.Compare(token1, token2);
            return stringCompare;
        }
    }
}

2

これは素朴な1行の正規表現なしのLINQ方法です(Pythonから借用):

var alphaStrings = new List<string>() { "10","2","3","4","50","11","100","a12","b12" };
var orderedString = alphaStrings.OrderBy(g => new Tuple<int, string>(g.ToCharArray().All(char.IsDigit)? int.Parse(g) : int.MaxValue, g));
// Order Now: ["2","3","4","10","11","50","100","a12","b12"]

Dump()を削除し、varに割り当てました。これは魅力のように機能します!
Arne S

@ArneS:それはLinQPadで書かれました。と削除するのを忘れましたDump()。ご指摘ありがとうございます。
mshsayem

1

以前のいくつかの回答を拡張し、拡張メソッドを使用して、潜在的な複数の列挙可能な列挙、または複数の正規表現オブジェクトの使用、または不必要な正規表現の呼び出しに関連するパフォーマンスの問題の警告がない次のことを思いつきました。言われているように、それはToList()を使用しますが、これはより大きなコレクションでの利点を打ち消す可能性があります。

セレクターは、ジェネリック型指定をサポートして、デリゲートを割り当てることができます。ソースコレクションの要素はセレクターによって変更され、ToString()を使用して文字列に変換されます。

    private static readonly Regex _NaturalOrderExpr = new Regex(@"\d+", RegexOptions.Compiled);

    public static IEnumerable<TSource> OrderByNatural<TSource, TKey>(
        this IEnumerable<TSource> source, Func<TSource, TKey> selector)
    {
        int max = 0;

        var selection = source.Select(
            o =>
            {
                var v = selector(o);
                var s = v != null ? v.ToString() : String.Empty;

                if (!String.IsNullOrWhiteSpace(s))
                {
                    var mc = _NaturalOrderExpr.Matches(s);

                    if (mc.Count > 0)
                    {
                        max = Math.Max(max, mc.Cast<Match>().Max(m => m.Value.Length));
                    }
                }

                return new
                {
                    Key = o,
                    Value = s
                };
            }).ToList();

        return
            selection.OrderBy(
                o =>
                String.IsNullOrWhiteSpace(o.Value) ? o.Value : _NaturalOrderExpr.Replace(o.Value, m => m.Value.PadLeft(max, '0')))
                     .Select(o => o.Key);
    }

    public static IEnumerable<TSource> OrderByDescendingNatural<TSource, TKey>(
        this IEnumerable<TSource> source, Func<TSource, TKey> selector)
    {
        int max = 0;

        var selection = source.Select(
            o =>
            {
                var v = selector(o);
                var s = v != null ? v.ToString() : String.Empty;

                if (!String.IsNullOrWhiteSpace(s))
                {
                    var mc = _NaturalOrderExpr.Matches(s);

                    if (mc.Count > 0)
                    {
                        max = Math.Max(max, mc.Cast<Match>().Max(m => m.Value.Length));
                    }
                }

                return new
                {
                    Key = o,
                    Value = s
                };
            }).ToList();

        return
            selection.OrderByDescending(
                o =>
                String.IsNullOrWhiteSpace(o.Value) ? o.Value : _NaturalOrderExpr.Replace(o.Value, m => m.Value.PadLeft(max, '0')))
                     .Select(o => o.Key);
    }

1

Michael Parkerのソリューションに触発されてIComparer、linq順序付けメソッドのいずれかにドロップできる実装があります。

private class NaturalStringComparer : IComparer<string>
{
    public int Compare(string left, string right)
    {
        int max = new[] { left, right }
            .SelectMany(x => Regex.Matches(x, @"\d+").Cast<Match>().Select(y => (int?)y.Value.Length))
            .Max() ?? 0;

        var leftPadded = Regex.Replace(left, @"\d+", m => m.Value.PadLeft(max, '0'));
        var rightPadded = Regex.Replace(right, @"\d+", m => m.Value.PadLeft(max, '0'));

        return string.Compare(leftPadded, rightPadded);
    }
}

0

次のパターンのテキストを処理する自然なソートが必要でした。

"Test 1-1-1 something"
"Test 1-2-3 something"
...

何らかの理由で最初にSOを調べたとき、この投稿が見つからなかったため、独自に実装しました。ここに提示されたいくつかのソリューションと比較すると、概念は似ていますが、シンプルで理解しやすいという利点があります。ただし、パフォーマンスのボトルネックを確認しようとしましたが、それでもデフォルトよりはるかに遅い実装ですOrderBy()

ここに私が実装する拡張メソッドがあります:

public static class EnumerableExtensions
{
    // set up the regex parser once and for all
    private static readonly Regex Regex = new Regex(@"\d+|\D+", RegexOptions.Compiled | RegexOptions.Singleline);

    // stateless comparer can be built once
    private static readonly AggregateComparer Comparer = new AggregateComparer();

    public static IEnumerable<T> OrderByNatural<T>(this IEnumerable<T> source, Func<T, string> selector)
    {
        // first extract string from object using selector
        // then extract digit and non-digit groups
        Func<T, IEnumerable<IComparable>> splitter =
            s => Regex.Matches(selector(s))
                      .Cast<Match>()
                      .Select(m => Char.IsDigit(m.Value[0]) ? (IComparable) int.Parse(m.Value) : m.Value);
        return source.OrderBy(splitter, Comparer);
    }

    /// <summary>
    /// This comparer will compare two lists of objects against each other
    /// </summary>
    /// <remarks>Objects in each list are compare to their corresponding elements in the other
    /// list until a difference is found.</remarks>
    private class AggregateComparer : IComparer<IEnumerable<IComparable>>
    {
        public int Compare(IEnumerable<IComparable> x, IEnumerable<IComparable> y)
        {
            return
                x.Zip(y, (a, b) => new {a, b})              // walk both lists
                 .Select(pair => pair.a.CompareTo(pair.b))  // compare each object
                 .FirstOrDefault(result => result != 0);    // until a difference is found
        }
    }
}

アイデアは、元の文字列を数字のブロックと数字以外のブロック("\d+|\D+")に分割することです。これはコストがかかる可能性のあるタスクであるため、エントリごとに1回だけ実行されます。次に、比較可能なオブジェクトの比較子を使用します(申し訳ありませんが、これを表現する適切な方法が見つかりません)。各ブロックを他の文字列の対応するブロックと比較します。

これをどのように改善できるか、そして主要な欠陥は何かについてフィードバックをお願いします。現時点では保守性が重要であり、現在これを非常に大きなデータセットで使用していないことに注意してください。


1
これは、構造的に異なる文字列を比較しようとするとクラッシュします。たとえば、「a-1」と「a-2」の比較はうまくいきますが、「a」と「1」の比較はうまくいきません。「a」.CompareTo(1)例外をスローします。
jimrandomh 2013年

@jimrandomh、あなたは正しいです。このアプローチは私たちのパターンに固有のものでした。
Eric Liprandi 2013年

0

読みやすく、維持しやすいバージョンです。

public class NaturalStringComparer : IComparer<string>
{
    public static NaturalStringComparer Instance { get; } = new NaturalStringComparer();

    public int Compare(string x, string y) {
        const int LeftIsSmaller = -1;
        const int RightIsSmaller = 1;
        const int Equal = 0;

        var leftString = x;
        var rightString = y;

        var stringComparer = CultureInfo.CurrentCulture.CompareInfo;

        int rightIndex;
        int leftIndex;

        for (leftIndex = 0, rightIndex = 0;
             leftIndex < leftString.Length && rightIndex < rightString.Length;
             leftIndex++, rightIndex++) {
            var leftChar = leftString[leftIndex];
            var rightChar = rightString[leftIndex];

            var leftIsNumber = char.IsNumber(leftChar);
            var rightIsNumber = char.IsNumber(rightChar);

            if (!leftIsNumber && !rightIsNumber) {
                var result = stringComparer.Compare(leftString, leftIndex, 1, rightString, leftIndex, 1);
                if (result != 0) return result;
            } else if (leftIsNumber && !rightIsNumber) {
                return LeftIsSmaller;
            } else if (!leftIsNumber && rightIsNumber) {
                return RightIsSmaller;
            } else {
                var leftNumberLength = NumberLength(leftString, leftIndex, out var leftNumber);
                var rightNumberLength = NumberLength(rightString, rightIndex, out var rightNumber);

                if (leftNumberLength < rightNumberLength) {
                    return LeftIsSmaller;
                } else if (leftNumberLength > rightNumberLength) {
                    return RightIsSmaller;
                } else {
                    if(leftNumber < rightNumber) {
                        return LeftIsSmaller;
                    } else if(leftNumber > rightNumber) {
                        return RightIsSmaller;
                    }
                }
            }
        }

        if (leftString.Length < rightString.Length) {
            return LeftIsSmaller;
        } else if(leftString.Length > rightString.Length) {
            return RightIsSmaller;
        }

        return Equal;
    }

    public int NumberLength(string str, int offset, out int number) {
        if (string.IsNullOrWhiteSpace(str)) throw new ArgumentNullException(nameof(str));
        if (offset >= str.Length) throw new ArgumentOutOfRangeException(nameof(offset), offset, "Offset must be less than the length of the string.");

        var currentOffset = offset;

        var curChar = str[currentOffset];

        if (!char.IsNumber(curChar))
            throw new ArgumentException($"'{curChar}' is not a number.", nameof(offset));

        int length = 1;

        var numberString = string.Empty;

        for (currentOffset = offset + 1;
            currentOffset < str.Length;
            currentOffset++, length++) {

            curChar = str[currentOffset];
            numberString += curChar;

            if (!char.IsNumber(curChar)) {
                number = int.Parse(numberString);

                return length;
            }
        }

        number = int.Parse(numberString);

        return length;
    }
}

-2

私の問題と、それをどのように解決できたかを説明しましょう。

問題:-ディレクトリから取得したFileInfoオブジェクトのFileNameに基づいてファイルをソートします。

解決策:-FileInfoからファイル名を選択し、ファイル名の「.png」部分を削除しました。次に、List.Sort()を実行します。これにより、ファイル名がNaturalのソート順でソートされます。私のテストに基づいて、.pngを使用すると並べ替え順序が台無しになることがわかりました。以下のコードを見てください

var imageNameList = new DirectoryInfo(@"C:\Temp\Images").GetFiles("*.png").Select(x =>x.Name.Substring(0, x.Name.Length - 4)).ToList();
imageNameList.Sort();

この回答で-1の理由を知ることはできますか?
girishkatta9
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.