List with no sequential repeats (where possible)
Here's an alternate way to do it. It doesn't involve modifying and reversing the existing list. Instead, it first groups and counts the items, then yields the one that wasn't printed last time and still needs to be yielded the most times. I'm not sure about actual runtime for large lists, but as long as the number of distinct items in the list is small, the reorderings and searches should run very fast.

public static IEnumerable&lt;T&gt; WithoutDupes&lt;T&gt;(this IEnumerable&lt;T&gt; source) where T : IEquatable&lt;T&gt;
{
    var sourceGroups = source.GroupBy(x =&gt; x).Select(x =&gt; new GroupCount&lt;T&gt;(x)).ToList();
    T last = default(T);
    bool hasLast = false;
    while (sourceGroups.Count &gt; 0)
    {
        sourceGroups = sourceGroups.OrderByDescending(x =&gt; x.Count - x.CountOutputted).ToList();
        var group = (hasLast ? sourceGroups.FirstOrDefault(x =&gt; !last.Equals(x.Value)) : null) ?? sourceGroups[0];

        yield return group.Value;
        group.CountOutputted++;
        if (group.CountOutputted == group.Count)
        {
            sourceGroups.Remove(group);
        }
        last = group.Value;
        hasLast = true;
    }
}
private class GroupCount&lt;T&gt;
{
    public T Value { get; private set; }
    public int Count { get; private set; }
    public int CountOutputted { get; set; }
    public GroupCount(IGrouping&lt;T, T&gt; grouping)
    {
        this.Value = grouping.Key;
        this.Count = grouping.Count();
    }
}


As example output, with your input, it produces this list (note how it handles the impossible case: puts the extra T's at the end)

T, G, T, G, T, G, T, G, T, G, T, M, T, M, T, G, T, G, T, M, T, M, T, G, T, T, T, T