如何在LINQ中按集对项目排序？

Question

I have this simple array with the following items:

[4, 3, 1, 1, 0, 0]

I want to sort it on this way:

[4, 3, 1, 0, 1, 0]

As you notice, I want to sort it on descending order. But on this case, there are two sets of array that was sorted on descending order:

4, 3, 1, 0 and 1, 0 

Which produce the output:

[4, 3, 1, 0, 1, 0]

I tried to do this using Group By:

var result = arrayInput.GroupBy(c => c).Select(a => a.OrderBy(d => d).First());

But this produces only 4, 3, 1, 0 and I need to append the not selected integers as sorted so that it will be:

[4, 3, 1, 0, 1, 0]

Answer 1

Here's how I'd do that. Basically you want to try putting each number into a group of sets. The first one that doesn't already have that number is the one it actually goes in and if none have it then you add a new set. In this way the first set will have all unique numbers, the second with have all numbers that are duplicated as least once, and so on. Then at the end you return items for each of the sets ordering each set as you go.

public static IEnumerable<int> SetSort(this IEnumerable<int> nums) {
    var sets = new List<HashSet<int>>();
    foreach(var num in nums) {
        bool added = false;
        foreach(var set in sets) {
            added = set.Add(num);
            if(added) break;
        }
        if(!added){
            sets.Add(new HashSet<int> { num });
        }
    }

    foreach(var set in sets) {
        foreach(var num in set.OrderByDescending(x => x)) {
            yield return num;
        }
    }
}

Answer 2

As usually Aggregate extension method can do everything

var data = new[] { 1, 2, 3, 4, 1, 0, 1, 0 };
var result = 
    data.GroupBy(i => i)
        .OrderByDescending(group => group.Key)
        .Aggregate(new { Keys = new List<int>(), Duplicates = new List<int>() }, 
                   (lists, group) =>
                   {
                       lists.Keys.Add(group.Key);
                       var duplicates = Enumerable.Repeat(group.Key, group.Count() - 1);
                       lists.Duplicates.AddRange(duplicates);
                       return lists;
                   },
                   lists => lists.Keys.Concat(lists.Duplicates));

// result is new[] { 4, 3, 2, 1, 0, 1, 1, 0 };

Approach with immutable collections

private IEnumerable<int> SortFunc(IEnumerable<int> data)
{
    var ordered = 
        data.GroupBy(i => i)
            .OrderByDescending(group => group.Key)
            .Select(group => new
            {
                Key = group.Key,
                Duplicates = group.Skip(1)
            });

    foreach (var key in ordered.Select(group => group.Key))
    {
        yield return key;
    }

    foreach (var value in ordered.SelectMany(group => group.Duplicates))
    {
        yield return value;
    }
}