Как быстро удалить элементы из списка

Ответ 1

Список не является эффективной структурой данных, когда дело доходит до удаления. Вам лучше использовать двойной связанный список (LinkedList), поскольку удаление просто требует обновлений ссылок в смежных записях.

Ответ 2

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

// This overload of Where provides the index as well as the value. Unless
// you need the index, use the simpler overload which just provides the value.
List<string> newList = oldList.Where((value, index) => index % 5 != 0)
                              .ToList();

Однако вы можете посмотреть альтернативные структуры данных, такие как LinkedList<T> или HashSet<T>. Это действительно зависит от того, какие функции вам нужны из вашей структуры данных.

Ответ 3

Я чувствую, что HashSet, LinkedList или Dictionary сделают вам намного лучше.

Ответ 4

Если порядок не имеет значения, тогда существует простой метод O (1) List.Remove.

public static class ListExt
{
    // O(1) 
    public static void RemoveBySwap<T>(this List<T> list, int index)
    {
        list[index] = list[list.Count - 1];
        list.RemoveAt(list.Count - 1);
    }

    // O(n)
    public static void RemoveBySwap<T>(this List<T> list, T item)
    {
        int index = list.IndexOf(item);
        RemoveBySwap(list, index);
    }

    // O(n)
    public static void RemoveBySwap<T>(this List<T> list, Predicate<T> predicate)
    {
        int index = list.FindIndex(predicate);
        RemoveBySwap(list, index);
    }
}

Это решение является дружественным для обхода памяти, поэтому даже если вам нужно сначала найти индекс, это будет очень быстро.

Примечания:

• Поиск индекса элемента должен быть O (n), поскольку список должен быть несортирован.
• Связанные списки медленны на обход, особенно для больших коллекций с длительным сроком службы.

Ответ 5

Вы всегда можете удалить элементы из конца списка. Удаление списка - это O (1), когда выполняется на последнем элементе, поскольку все, что он делает, - это счетчик уменьшения. Не происходит смещения следующих элементов. (именно поэтому удаление списка - O (n) в целом)

for (int i = list.Count - 1; i >= 0; --i)
  list.RemoveAt(i);

Ответ 6

Выполните попытку RemoveAll, используемую как

static void Main(string[] args)
{
    Stopwatch watch = new Stopwatch();
    watch.Start();
    List<Int32> test = GetList(500000);
    watch.Stop(); Console.WriteLine(watch.Elapsed.ToString());
    watch.Reset(); watch.Start();
    test.RemoveAll( t=> t % 5 == 0);
    List<String> test2 = test.ConvertAll(delegate(int i) { return i.ToString(); });
    watch.Stop(); Console.WriteLine(watch.Elapsed.ToString());

    Console.WriteLine((500000 - test.Count).ToString());
    Console.ReadLine();

}

static private List<Int32> GetList(int size)
{
    List<Int32> test = new List<Int32>();
    for (int i = 0; i < 500000; i++)
        test.Add(i);
    return test;
}

это только петли два раза и эффективно удаляет 100 000 элементов

Мой вывод для этого кода:

00:00:00.0099495 
00:00:00.1945987 
1000000

Обновлено, чтобы попробовать HashSet

static void Main(string[] args)
    {
        Stopwatch watch = new Stopwatch();
        do
        {
            // Test with list
            watch.Reset(); watch.Start();
            List<Int32> test = GetList(500000);
            watch.Stop(); Console.WriteLine(watch.Elapsed.ToString());
            watch.Reset(); watch.Start();
            List<String> myList = RemoveTest(test);
            watch.Stop(); Console.WriteLine(watch.Elapsed.ToString());
            Console.WriteLine((500000 - test.Count).ToString());
            Console.WriteLine();

            // Test with HashSet
            watch.Reset(); watch.Start();
            HashSet<String> test2 = GetStringList(500000);
            watch.Stop(); Console.WriteLine(watch.Elapsed.ToString());
            watch.Reset(); watch.Start();
            HashSet<String> myList2 = RemoveTest(test2);
            watch.Stop(); Console.WriteLine(watch.Elapsed.ToString());
            Console.WriteLine((500000 - test.Count).ToString());
            Console.WriteLine();
        } while (Console.ReadKey().Key != ConsoleKey.Escape);

    }

    static private List<Int32> GetList(int size)
    {
        List<Int32> test = new List<Int32>();
        for (int i = 0; i < 500000; i++)
            test.Add(i);
        return test;
    }

    static private HashSet<String> GetStringList(int size)
    {
        HashSet<String> test = new HashSet<String>();
        for (int i = 0; i < 500000; i++)
            test.Add(i.ToString());
        return test;
    }

    static private List<String> RemoveTest(List<Int32> list)
    {
        list.RemoveAll(t => t % 5 == 0);
        return list.ConvertAll(delegate(int i) { return i.ToString(); });
    }

    static private HashSet<String> RemoveTest(HashSet<String> list)
    {
        list.RemoveWhere(t => Convert.ToInt32(t) % 5 == 0);
        return list;
    }

Это дает мне:

00:00:00.0131586
00:00:00.1454723
100000

00:00:00.3459420
00:00:00.2122574
100000

Ответ 7

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

List<long> hundredThousandItemsInOrignalList;
List<long> fiftyThousandItemsToRemove;

// populate lists...

Dictionary<long, long> originalItems = hundredThousandItemsInOrignalList.ToDictionary(i => i);

foreach (long i in fiftyThousandItemsToRemove)
{
    originalItems.Remove(i);
}

List<long> newList = originalItems.Select(i => i.Key).ToList();

Ответ 8

Или вы можете это сделать:

List<int> listA;
List<int> listB;

...

List<int> resultingList = listA.Except(listB);

Ответ 9

Другие ответы (и сам вопрос) предлагают различные способы борьбы с этой "пробкой" (ошибкой медлительности) с использованием встроенных классов .NET Framework.

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

Библиотеки Loyc Core включают два типа, которые работают так же, как List<T>, но могут быстрее удалять элементы:

• DList<T> - это простая структура данных, которая дает вам 2x ускорение поверх List<T> при удалении элементов из случайных местоположений
• AList<T> - сложная структура данных, которая дает вам большое ускорение над List<T>, когда ваши списки очень длинные (но могут быть медленнее, когда список короткий).

Ответ 10

Списки быстрее, чем LinkedLists, пока n не станет действительно большим. Причина этого в том, что так называемые промахи кэшей происходят чаще, используя LinkedLists, чем списки. Память выглядит довольно дорого. Поскольку список реализован как массив, центральный процессор может загружать кучу данных одновременно, поскольку он знает, что необходимые данные хранятся рядом друг с другом. Однако связанный список не дает процессору никакого намека на то, какие данные требуются в следующем, что заставляет ЦП делать больше обращений к памяти. Кстати. С памятью термина я имею в виду ОЗУ.

Для получения дополнительной информации смотрите: https://jackmott.github.io/programming/2016/08/20/when-bigo-foolsya.html