C# 按给定排序顺序排序集合

我有一个字符串列表，我想按一定的顺序排列。假设该列表包含随机数量的字符串“a”、“B”和“C”。我还有另一个包含排序顺序的字符串列表

例如： 输入：

“A”

“A”

“C”

“B”

“B”

“C”

使用排序顺序列表：

“A”

“B”

“C”

我想对该列表进行排序，使其输出如下所示：

“A”

“B”

“C”

“A”

“B”

“C”

另一个例子：

输入：

“A”

“A”

“C”

“B”

“C”

使用排序顺序列表：

“A”

“C”

“B”

输出应如下所示：

“A”

“C”

“B”

“A”

“C”

注意：我选择A、B和C只是为了简单，所以在我的实际应用程序中，我不能使用任何字母顺序

---

有没有办法达到预期的效果？我为此绞尽脑汁好几天，没有想出解决办法。我试图实现IComparer，但我正在与compare-method的条件作斗争

我认为这符合您的需要：

        var list = new List<string> { "A", "B", "E", "A", "E", "A", "B", "E", "C", "B", "A", "D", "B", "E" };
        var sortOrder = new List<string> { "F", "E", "C", "A", "B", "D" };

        var resultSets = new List<List<string>> ();
        for (int i = 0; i < sortOrder.Count(); i++)
        {
            var currentLetter = sortOrder[i];
            for (int j = 0; j < list.Count(x=> x == currentLetter); j++)
            {
                if(resultSets.Count() < j + 1)
                {
                    resultSets.Add(new List<string>());
                }
                resultSets[j].Add(currentLetter);
            }
        }
        var result = string.Join(", ", resultSets.SelectMany(x => x));
        Console.WriteLine($"Results: { result}");

var list=新列表{“A”、“B”、“E”、“A”、“E”、“A”、“B”、“E”、“C”、“B”、“A”、“D”、“B”、“E”}；
var sortOrder=新列表{“F”、“E”、“C”、“A”、“B”、“D”}；
var resultSets=新列表（）；
for（int i=0；ix==currentLetter）；j++）
{
if（resultSets.Count（）x））；
WriteLine（$“Results:{result}”）；

尽管公认的答案是有效的，但如果输入枚举和/或模式足够大，那么性能会非常糟糕。如果为作业选择更充分的集合，则可以显著提高性能：

public static IEnumerable<T> GetChunks<T>(this IEnumerable<T> source, IEnumerable<T> pattern)
    where T: IEquatable<T>
{
    var dictionary = pattern.ToDictionary(p => p, p => new Stack<T>());

    foreach (var item in source)
    {
        dictionary[item].Push(item);
    }

    var rest = source.Except(pattern);

    while (dictionary.Values.Any(q => q.Any()))
    {
        foreach (var p in pattern)
        {
            if (dictionary[p].Count  >0)
            {
                yield return dictionary[p].Pop();
            }
        }
    }

    foreach (var r in rest)
    {
        yield return r;
    }
}

公共静态IEnumerable GetChunks（此IEnumerable源，IEnumerable模式）
其中T:i可满足
{
var dictionary=pattern.ToDictionary（p=>p，p=>newstack（））；
foreach（源中的var项）
{
字典[项目]。推送（项目）；
}
var rest=源。除（模式）外；
while（dictionary.Values.Any（q=>q.Any（）））
{
foreach（模式中的var p）
{
如果（字典[p]。计数>0）
{
收益返回字典[p].Pop（）；
}
}
}
foreach（静止时的var r）
{
收益率r；
}
}

这里的诀窍是建立一个廉价的字典，以利用它提供的快速查找

---

我还冒昧地决定将所有不匹配的元素添加到“有序”结果的末尾。这可能不是您想要的，但这方面的问题没有明确说明。

您已经尝试了什么？给我们一些代码，看看你不想让我们为你做你的工作。你已经试过了吗？`你在哪里卡住了？欢迎来到堆栈溢出。请先检查堆栈溢出。把注意力集中在、、和上。我认为你的排序表很混乱。上面写着：按A排序，然后按B排序，然后按C排序，但你的意思是：给我一大块ABC，如果没有ABC可用，给我剩下的sorted@Marc威特曼：是的，你是对的。也许我对此有点不清楚。我想不需要查找。但是，如果您希望按区分字段进行排序，则可以使用Skip，但对象的其余部分需要保留在结果中。当然，这不是一个要求，所以我把它省略了。次要说明，

List

有一个

Count

属性，应该用于外部for循环，而不是

Count（）

扩展。属性的速度要快得多。对于

resultSets.Count（）

=>

resultSets.Count

.Good point Brandon.：）也是如此@JR Kincaid非常感谢你！先生，你让我高兴极了！谢谢你的回答。在稍微修改代码以满足我的需要后，我将使用它，即使我已经接受JR Kincaids的答案，因为您的解决方案考虑了性能方面。一些旁注：我必须检查dictionary.ContainsKey（item）以确保它能够工作，即使不是所有模式集合的值都存在于源集合中（我对这种情况不是特别关注，所以不要将其视为批评）。另一个旁注：让“rest-stuff”工作起来（我不需要，但感谢您的努力！）与预期一样，行

var rest=source.Except（pattern）

应该更改为类似的内容，我认为：

var rest=source.Where（x=>source.Except（pattern.Any（y=>y.Equals（x））。