C# Список сортировки на основе другого списка

Question

У меня есть класс, который содержит несколько списков <>, содержащихся в нем. Его в основном таблица, хранящаяся с каждым столбцом в виде списка <>. Каждый столбец не имеет одного и того же типа. Каждый список имеет одинаковую длину (имеет одинаковое количество элементов).

Например:

У меня есть 3 списка <> объекты; один список, два списка и три списка.

//Not syntactically correct 
List<DateTime> one = new List...{4/12/2010, 4/9/2006, 4/13/2008}; 
List<double> two = new List...{24.5, 56.2, 47.4}; 
List<string> three = new List...{"B", "K", "Z"}; 

Я хочу, чтобы иметь возможность сортировать список один из старых к новым: один = {4/9/2006, 4/13/2008, 4/12/2010};

Чтобы сделать это, я переместил элемент 0 до конца.

Затем я хочу отсортировать список два и три одинаково; перемещая первое и последнее.

Поэтому, когда я сортирую один список, я хочу, чтобы данные в соответствующем индексе в других списках также менялись в соответствии с тем, как отсортирован один список.

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

Answer 1

Сначала вы должны создать объект Data для хранения всего.

private class Data 
{ 
    public DateTime DateTime { get; set; } 
    public int Int32 { get; set; } 
    public string String { get; set; } 
} 

Тогда вы можете отсортировать как это.

var l = new List<Data>(); 
l.Sort(
    (a, b) => 
    { 
     var r = a.DateTime.CompareTo(b); 
     if (r == 0) 
     { 
      r = a.Int32.CompareTo(b); 
      if (r == 0) 
      { 
       r = a.String.CompareTo(b); 
      } 
     } 
     return r; 
    } 
); 

Answer 2

Я обработал этот проект в прошлом, сохранив или создав отдельный индексный список. Сначала вы сортируете индексный список, а затем используете его для сортировки (или просто доступа) к другим спискам. Вы можете сделать это, создав пользовательский IComparer для списка индексов. Что вы делаете внутри этого IComparer, чтобы сравнить на основе индексов в списке ключей. Другими словами, вы сортируете индексный список опосредованно. Что-то вроде:

// This is the compare function for the separate *index* list. 
int Compare (object x, object y) 
{ 
    KeyList[(int) x].CompareTo(KeyList[(int) y]) 
} 

Таким образом, вы сортируете индексный список на основе значений в списке ключей. Затем вы можете использовать этот отсортированный список ключей для повторного заказа других списков. Если это неясно, я попытаюсь добавить более полный пример, когда я попаду в ситуацию, чтобы опубликовать его.

Answer 3

Используя общие массивы, это может стать немного громоздким.

Один из вариантов использует метод Array.Sort(), который принимает массив ключей и массив значений для сортировки. Сначала он сортирует массив ключей в порядке возрастания и гарантирует, что массив значений будет реорганизован для соответствия этому порядку сортировки.

Если вы желаете понести стоимость конвертации List<T> s в массивы (а затем назад), вы можете воспользоваться этим методом.

В качестве альтернативы вы можете использовать LINQ для объединения значений из нескольких массивов в один анонимный тип с использованием Zip(), сортировки списка анонимных типов с использованием поля ключа, а затем разделить их на отдельные массивы.

Если вы хотите сделать это на месте, вам придется написать собственный сопоставитель и создать отдельный индексный массив для поддержания нового порядка элементов.

Answer 4

Прошу прощения, но это похоже на плохой дизайн. Тем более, что список <T> не гарантирует порядок элементов, прежде чем вы назвали одну из сортировочных операций (так у вас есть проблемы при вставке):

From MSDN:

Список не гарантируется быть отсортирован. Перед выполнением операций (например, BinarySearch) необходимо отсортировать список , который требует сортировки списка .

Во многих случаях вы не столкнетесь с проблемами, основанными на этом, но можете, и если вы это сделаете, это может быть очень трудная ошибка для отслеживания. Например, я думаю, что текущая реализация структуры List <T> поддерживает порядок вставки до сортировки, но может измениться в будущем.

Я бы серьезно подумал о том, чтобы рефакторинг использовал другую структуру данных. Если вы все еще хотите реализовать сортировку на основе этой структуры данных, я бы создал временный объект (возможно, используя анонимный тип), сортировка этого и повторное создание списков (see this excellent answer для объяснения того, как).

Answer 5

Я надеюсь, что это может помочь:

one = one.Sort(delegate(DateTime d1, DateTime d2) 
{ 
    return Convert.ToDateTime(d2).CompareTo(Convert.ToDateTime(d1)); 
}); 

Answer 6

Я написал алгоритм сортировки, который делает это для Nito.LINQ (еще не выпущен). Он использует простодушный QuickSort для сортировки списков и позволяет синхронизировать любое количество связанных списков. Source code starts here, in the IList<T>.Sort extension method.

В качестве альтернативы, если копирование данных не является огромной проблемой, вы можете проецировать его в запрос LINQ, используя оператор Zip (требует .NET 4.0 или Rx), порядок его, а затем потяните каждый результат из:

List<DateTime> one = ...; 
List<double> two = ...; 
List<string> three = ...; 
var combined = one.Zip(two, (first, second) => new { first, second }) 
    .Zip(three, (pair, third) => new { pair.first, pair.second, third }); 
var ordered = combined.OrderBy(x => x.first); 
var orderedOne = ordered.Select(x => x.first); 
var orderedTwo = ordered.Select(x => x.second); 
var orderedThree = ordered.Select(x => x.third); 

Естественно, лучшим решением является не разделение связанных данных в первую очередь.

Answer 7

Вот как это сделать, используя LINQ и проекции. Первый запрос генерирует массив с исходными индексами, переупорядоченными значениями даты и времени; в вашем примере, массив newOrdering бы члены:

{ 4/9/2006, 1 }, { 4/13/2008, 2 }, { 4/12/2010, 0 }

Второй набор операторов генерировать новые списки, выбирая предметы, используя переупорядоченные индексы (другими словами, пункты 1, 2 и 0, в том заказ).

var newOrdering = one 
    .Select((dateTime, index) => new { dateTime, index }) 
    .OrderBy(item => item.dateTime) 
    .ToArray(); 

// now, order each list 
one = newOrdering.Select(item => one[item.index]).ToList(); 
two = newOrdering.Select(item => two[item.index]).ToList(); 
three = newOrdering.Select(item => three[item.index]).ToList();