Топологическая сортировка с использованием LINQ

Ответ 1

Я бы предложил использовать тот же интерфейс IComparer, но написал метод расширения, чтобы интерпретировать 0 как не относящийся. В частичном порядке, если элементы a и b равны, их порядок не имеет значения, так же, если они не связаны друг с другом - вам нужно только упорядочить их по отношению к элементам, с которыми они определили отношения.

Здесь пример, который выполняет частичное упорядочение четных и нечетных целых чисел:

namespace PartialOrdering
{
    public static class Enumerable
    {
        public static IEnumerable<TSource> PartialOrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
        {
            List<TSource> list = new List<TSource>(source);
            while (list.Count > 0)
            {
                TSource minimum = default(TSource);
                TKey minimumKey = default(TKey);
                foreach (TSource s in list)
                {
                    TKey k = keySelector(s);
                    minimum = s;
                    minimumKey = k;
                    break;
                }
                foreach (TSource s in list)
                {
                    TKey k = keySelector(s);
                    if (comparer.Compare(k, minimumKey) < 0)
                    {
                        minimum = s;
                        minimumKey = k;
                    }
                }
                yield return minimum;
                list.Remove(minimum);
            }
            yield break;
        }

    }
    public class EvenOddPartialOrdering : IComparer<int>
    {
        public int Compare(int a, int b)
        {
            if (a % 2 != b % 2)
                return 0;
            else if (a < b)
                return -1;
            else if (a > b)
                return 1;
            else return 0; //equal
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            IEnumerable<Int32> integers = new List<int> { 8, 4, 5, 7, 10, 3 };
            integers = integers.PartialOrderBy<Int32, Int32>(new Func<Int32, Int32>(delegate(int i) { return i; }), new EvenOddPartialOrdering());
        }
    }
}

Результат: 4, 8, 3, 5, 7, 10

Ответ 2

Это моя оптимизированная и отредактированная версия ответа tehMick.

Одно изменение, которое я сделал, это замена реального списка значений, оставшихся для вывода для логического списка. Для этого у меня два массива размера одинакового размера. У одного есть все значения, а остальные содержат флажки, указывающие, было ли получено каждое значение. Таким образом, я избегаю затрат на изменение размера реального List<Key>.

Еще одно изменение заключается в том, что я читаю все ключи только один раз в начале итерации. По причинам, которые я не могу вспомнить сейчас (возможно, это был мой инстинкт) мне не нравится идея вызвать функцию keySelector несколько раз.

Последнее касалось проверки параметров и дополнительной перегрузки, которая использует неявный ключ-сопоставитель. Надеюсь, код достаточно читаем. Проверьте это.

public static IEnumerable<TSource> PartialOrderBy<TSource, TKey>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector)
{
    return PartialOrderBy(source, keySelector, null);
}

public static IEnumerable<TSource> PartialOrderBy<TSource, TKey>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector,
    IComparer<TKey> comparer)
{
    if (source == null) throw new ArgumentNullException("source");
    if (keySelector == null) throw new ArgumentNullException("keySelector");
    if (comparer == null) comparer = (IComparer<TKey>)Comparer<TKey>.Default;

    return PartialOrderByIterator(source, keySelector, comparer);
}

private static IEnumerable<TSource> PartialOrderByIterator<TSource, TKey>(
    IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector,
    IComparer<TKey> comparer)
{
    var values = source.ToArray();
    var keys = values.Select(keySelector).ToArray();
    int count = values.Length;
    var notYieldedIndexes = System.Linq.Enumerable.Range(0, count).ToArray();
    int valuesToGo = count;

    while (valuesToGo > 0)
    {
        //Start with first value not yielded yet
        int minIndex = notYieldedIndexes.First( i => i >= 0);

        //Find minimum value amongst the values not yielded yet
        for (int i=0; i<count; i++)
        if (notYieldedIndexes[i] >= 0)
        if (comparer.Compare(keys[i], keys[minIndex]) < 0) {
            minIndex = i;
        }

        //Yield minimum value and mark it as yielded
        yield return values[minIndex];
        notYieldedIndexes[minIndex] = -1;
        valuesToGo--;
    }
}

Ответ 3

Ну, я не уверен, что этот способ обращения с ним - лучший способ, но я могу ошибаться.

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

Однако, чтобы получить эти соединения, в первую очередь, с помощью вашего метода вам понадобится:

• Метод (ваш компаратор), который мог бы сказать "это до этого", но также "нет информации для этих двух"
• Итерировать все комбинации, создавая соединения для всех комбинаций, которые компаратор возвращает для заказа.

Другими словами, метод, вероятно, будет определен следующим образом:

public Int32? Compare(TKey a, TKey b) { ... }

а затем верните null, когда он не имеет окончательного ответа для двух ключей.

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

Ответ 4

Я считаю, что ответ Lasse V. Karlsen находится на правильном пути, но мне не нравится скрывать метод Compare (или отдельный интерфейс для этого который не простирается от IComparable<T>).

Вместо этого я бы предпочел бы что-то вроде этого:

public interface IPartialOrderComparer<T> : IComparer<T>
{
    int? InstancesAreComparable(T x, T y);
}

Таким образом, у вас все еще есть реализация IComparer<T>, которую можно использовать в других местах, для которых требуется IComparer<T>.

Однако для этого также требуется указать связь экземпляров T друг с другом с возвращаемым значением следующим образом (аналогично IComparable<T>):

• null - экземпляры не сопоставимы друг с другом.
• 0 - экземпляры сопоставимы друг с другом.

• 0 - x является сопоставимым ключом, но y не является.

• < 0 - y является сопоставимым ключом, но x не является.

Конечно, вы не будете получать частичный заказ при передаче реализации этого ко всему, что ожидает IComparable<T> (и следует отметить, что ответ Лассе В. Карлсена тоже не решает), как то, что вам нужно не может быть представлен простым методом сравнения, который принимает два экземпляра T и возвращает int.

Чтобы завершить решение, вы должны предоставить собственный метод OrderBy (а также ThenBy, OrderByDescending и ThenByDescending), который примет новый параметр экземпляра (как вы уже указали). Реализация будет выглядеть примерно так:

public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(      
    this IEnumerable<TSource> source,      
    Func<TSource, TKey> keySelector,      
    IPartialOrderComparer<TKey> comparer)
{
    return Enumerable.OrderBy(source, keySelector,
        new PartialOrderComparer(comparer);
}

internal class PartialOrderComparer<T> : IComparer<T>
{
    internal PartialOrderComparer(IPartialOrderComparer<T> 
        partialOrderComparer)
    {
        this.partialOrderComparer = partialOrderComparer;
    }

    private readonly IPartialOrderComparer<T> partialOrderComparer;

    public int Compare(T x, T y)
    {
        // See if the items are comparable.
        int? comparable = partialOrderComparable.
            InstancesAreComparable(x, y);

        // If they are not comparable (null), then return
        // 0, they are equal and it doesn't matter
        // what order they are returned in.
        // Remember that this only to determine the
        // values in relation to each other, so it's
        // ok to say they are equal.
        if (comparable == null) return 0;

        // If the value is 0, they are comparable, return
        // the result of that.
        if (comparable.Value == 0) return partialOrderComparer.Compare(x, y);

        // One or the other is uncomparable.
        // Return the negative of the value.
        // If comparable is negative, then y is comparable
        // and x is not.  Therefore, x should be greater than y (think
        // of it in terms of coming later in the list after
        // the ordered elements).
        return -comparable.Value;            
    }
}

Ответ 5

Интерфейс для определения отношения частичного порядка:

interface IPartialComparer<T> {
    int? Compare(T x, T y);
}

Compare должен возвращать -1, если x < y, 0, если x = y, 1, если y < x и null, если x и y не сопоставимы.

Наша цель - вернуть порядок элементов в частичном порядке, который учитывает перечисление. То есть мы ищем последовательность e_1, e_2, e_3, ..., e_n элементов в частичном порядке так, что если i <= j и e_i сравнимо с e_j, то e_i <= e_j. Я сделаю это, используя поиск по глубине.

Класс, реализующий топологическую сортировку с использованием поиска по глубине:

class TopologicalSorter {
    class DepthFirstSearch<TElement, TKey> {
        readonly IEnumerable<TElement> _elements;
        readonly Func<TElement, TKey> _selector;
        readonly IPartialComparer<TKey> _comparer;
        HashSet<TElement> _visited;
        Dictionary<TElement, TKey> _keys;
        List<TElement> _sorted;

        public DepthFirstSearch(
            IEnumerable<TElement> elements,
            Func<TElement, TKey> selector,
            IPartialComparer<TKey> comparer
        ) {
            _elements = elements;
            _selector = selector;
            _comparer = comparer;
            var referenceComparer = new ReferenceEqualityComparer<TElement>();
            _visited = new HashSet<TElement>(referenceComparer);
            _keys = elements.ToDictionary(
                e => e,
                e => _selector(e), 
                referenceComparer
            );
            _sorted = new List<TElement>();
        }

        public IEnumerable<TElement> VisitAll() {
            foreach (var element in _elements) {
                Visit(element);
            }
            return _sorted;
        }

        void Visit(TElement element) {
            if (!_visited.Contains(element)) {
                _visited.Add(element);
                var predecessors = _elements.Where(
                    e => _comparer.Compare(_keys[e], _keys[element]) < 0
                );
                foreach (var e in predecessors) {
                    Visit(e);
                }
                _sorted.Add(element);
            }
        }
    }

    public IEnumerable<TElement> ToplogicalSort<TElement, TKey>(
        IEnumerable<TElement> elements,
        Func<TElement, TKey> selector, IPartialComparer<TKey> comparer
    ) {
        var search = new DepthFirstSearch<TElement, TKey>(
            elements,
            selector,
            comparer
        );
        return search.VisitAll();
    }
}

Класс помощника, необходимый для маркировки узлов при посещении при выполнении поиска по глубине:

class ReferenceEqualityComparer<T> : IEqualityComparer<T> {
    public bool Equals(T x, T y) {
        return Object.ReferenceEquals(x, y);
    }

    public int GetHashCode(T obj) {
        return obj.GetHashCode();
    }
}

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

Алгоритм работает путем выполнения поиска по глубине через элементы, добавляющие элемент e к линейному упорядочению (представленному _sorted в алгоритме), если мы уже добавили все предшественники e уже был добавлен к заказу. Следовательно, для каждого элемента e, если мы его еще не посетили, посетите его предшественники, а затем добавьте e. Таким образом, это ядро ​​алгоритма:

public void Visit(TElement element) {
    // if we haven't already visited the element
    if (!_visited.Contains(element)) {
        // mark it as visited
        _visited.Add(element);
        var predecessors = _elements.Where(
            e => _comparer.Compare(_keys[e], _keys[element]) < 0
        );
        // visit its predecessors
        foreach (var e in predecessors) {
            Visit(e);
        }
        // add it to the ordering
        // at this point we are certain that
        // its predecessors are already in the ordering
        _sorted.Add(element);
    }
}

В качестве примера рассмотрим частичный порядок, определенный на подмножествах {1, 2, 3}, где x < y, если x - подмножество y. Я реализую это следующим образом:

public class SetComparer : IPartialComparer<HashSet<int>> {
    public int? Compare(HashSet<int> x, HashSet<int> y) {
        bool xSubsety = x.All(i => y.Contains(i));
        bool ySubsetx = y.All(i => x.Contains(i));
        if (xSubsety) {
            if (ySubsetx) {
                return 0;
            }
            return -1;
        }
        if (ySubsetx) {
            return 1;
        }
        return null;
    }
}

Затем с sets, определяемым как список подмножеств {1, 2, 3}

List<HashSet<int>> sets = new List<HashSet<int>>() {
    new HashSet<int>(new List<int>() {}),
    new HashSet<int>(new List<int>() { 1, 2, 3 }),
    new HashSet<int>(new List<int>() { 2 }),
    new HashSet<int>(new List<int>() { 2, 3}),
    new HashSet<int>(new List<int>() { 3 }),
    new HashSet<int>(new List<int>() { 1, 3 }),
    new HashSet<int>(new List<int>() { 1, 2 }),
    new HashSet<int>(new List<int>() { 1 })
};
TopologicalSorter s = new TopologicalSorter();
var sorted = s.ToplogicalSort(sets, set => set, new SetComparer());

Это приводит к упорядочению:

{}, {2}, {3}, {2, 3}, {1}, {1, 3}, {1, 2}, {1, 2, 3}

который учитывает частичный порядок.

Это было очень весело. Спасибо.

Ответ 6

Большое спасибо всем, начиная с ответа Эрика Микельсена. Я придумал свою версию, поскольку я предпочитаю использовать нулевые значения, чтобы не указывать никакого отношения, как сказал Лассе В. Карлсен.

public static IEnumerable<TSource> PartialOrderBy<TSource>(
        this IEnumerable<TSource> source,            
        IPartialEqualityComparer<TSource> comparer)
    {
        if (source == null) throw new ArgumentNullException("source");
        if (comparer == null) throw new ArgumentNullException("comparer");


        var set = new HashSet<TSource>(source);
        while (!set.IsEmpty())
        {
            TSource minimum = set.First();                

            foreach (TSource s in set)
            {                    
                var comparison = comparer.Compare(s, minimum);
                if (!comparison.HasValue) continue;
                if (comparison.Value <= 0)
                {
                    minimum = s;                        
                }
            }
            yield return minimum;
            set.Remove(minimum);
        }
    }

public static IEnumerable<TSource> PartialOrderBy<TSource>(
       this IEnumerable<TSource> source,
       Func<TSource, TSource, int?> comparer)
    {
        return PartialOrderBy(source, new PartialEqualityComparer<TSource>(comparer));
    }

то у меня есть следующий интерфейс для сравнения

public interface IPartialEqualityComparer<T>
{
    int? Compare(T x, T y);
}

и этот вспомогательный класс

internal class PartialEqualityComparer<TSource> : IPartialEqualityComparer<TSource>
{
    private Func<TSource, TSource, int?> comparer;

    public PartialEqualityComparer(Func<TSource, TSource, int?> comparer)
    {
        this.comparer = comparer;
    }

    public int? Compare(TSource x, TSource y)
    {
        return comparer(x,y);
    }
}

что позволяет немного улучшить использование, поэтому мои тесты могут выглядеть следующим образом:

 var data = new int[] { 8,7,6,5,4,3,2,1,0 };
 var partiallyOrdered = data.PartialOrderBy((x, y) =>
     {
        if (x % 2 == 0 && y % 2 != 0) return null;
        return x.CompareTo(y);
     });