Коллекция вопросов ❓ на собеседовании в C# 🍧

Обзор вопросов по языка програмиированию C# и технологии NET

Project maintained by Dvurechensky-Docs Hosted on GitHub Pages — Theme by mattgraham

📋 Чем `List'T'` отличается от других коллекций?

✨ Оглавление

✨ Оглавление

⬆ Вернуться к главной

🔑 Коротко — что такое `List<T>`

List<T> — это динамический массив: под капотом он хранит элементы в одном T[] _items. Поведение похоже на обычный массив, но:

автоматически расширяется при добавлении элементов;
обеспечивает быстрый доступ по индексу (O(1));
вставки/удаления не в конце требуют сдвига элементов (O(n)).

🧩 Основные характеристики `List<T>`

Бэкенд: T[] _items — один непрерывный буфер памяти.
Count vs Capacity:
- Count — текущие элементы;
- Capacity — длина внутреннего массива. Capacity >= Count. При добавлении, если Count == Capacity, список расширяется (копирование в новый массив).
Добавление: Add — амортизированное O(1) (иногда O(n) при росте).
Доступ по индексу: list[i] — O(1).
Insert/RemoveAt: O(n) (сдвиг элементов).
Search/Contains/IndexOf: O(n).
BinarySearch: O(log n) — требуется отсортированный список.
Sort: обычно O(n log n); сортировка не гарантированно стабильна (если важна стабильность — используйте OrderBy).
Enumerator: List<T>.Enumerator — struct (избегает аллокации при foreach в большинстве случаев). При приведении к IEnumerable/IEnumerator — возможен боксинг.
Идентичность equality/поиск: использует EqualityComparer<T>.Default.
Не потокобезопасен: многопоточный доступ требует внешней синхронизации или concurrent-коллекций.

🧠 В чём преимущества `List<T>` перед другими коллекциями

Против `T[]` (статический массив)

T[] — фиксированного размера. List<T> — автоматически расширяемый.
Доступ по индексу у обоих O(1).
T[] может быть чуть быстрее (меньше обёрток) и менее затратен в аллокациях, если размер известен заранее.

Против `LinkedList<T>`

List<T> — лучшее кэш-поведение (локальность памяти), быстрее перебор и доступ по индексу.
LinkedList<T> даёт O(1) вставку/удаление, если есть LinkedListNode<T>; но доступ по индексу — O(n).
LinkedList<T> использует много объектов (nodes), поэтому память и GC-нагрузка выше.

Против `Queue<T>` / `Stack<T>`

Семантика отличается: FIFO/LIFO у очереди/стека.
По реализации Queue<T>/Stack<T> тоже используют массивы/кольца и предлагают быстрые push/pop/peek, но List<T> — универсальнее (индекс, range, сортировка).

Против `HashSet<T>` / `Dictionary<TKey,TValue>`

Hash структуры дают O(1) поиск/вставку по ключу (амортиз.), List<T> — O(n) в поиске.
Если нужен быстрый поиск/уникальность/словарь — используйте HashSet/Dictionary. List<T> — для упорядоченного списка и доступа по индексу.

Против `SortedSet<T>` / `SortedDictionary<TKey,TValue>`

Эти структуры поддерживают упорядоченность и логарифмические операции (RB-деревья). List<T> можно сортировать, но вставка в середину поддерживаемого порядка — O(n).

Против `ObservableCollection<T>` / `ReadOnlyCollection<T>`

ObservableCollection<T> — List<T> + уведомления (INotifyCollectionChanged) — для биндинга UI.
ReadOnlyCollection<T> — просто оболочка над IList<T> → обычно использует List<T> внутри.

Против `ConcurrentBag/Queue/Dictionary`

List<T> не потокобезопасен; конкаррентные коллекции оптимизированы для параллельного доступа.

Против `ImmutableList<T>` (immutable collections)

List<T> — изменяемый; immutable коллекции дают безопасные многопоточные неизменяемые структуры, но дороже при изменениях (создают новые версии).

⚙️ Внутренние детали и поведение (что важно знать)

Расширение буфера (growth)

Когда нужно больше места, List<T> выделяет новый массив и копирует элементы. Обычно размер увеличивается примерно вдвое (амортизированная стратегия роста).
При больших массивах это приводит к дополнительной аллокации и копированию → высокая нагрузка GC, особенно если массив уходит в LOH (Large Object Heap) — тогда компактизации сложнее.

Конструкторы

new List<T>() — чаще использует статический пустой массив; реальное выделение происходит при первом Add.
new List<T>(int capacity) — заранее выделяет нужный буфер.
new List<T>(IEnumerable<T>) — если источник реализует ICollection<T>, то пред-выделяется нужный массив и выполняется копирование без лишних расширений.

`TrimExcess()`

Уменьшает Capacity к Count, чтобы освободить неиспользуемую память; может не менять capacity, если экономия мала (реализует порог). Вызов приведёт к копированию.

`AsReadOnly()` и `ToArray()`

AsReadOnly() возвращает оболочку ReadOnlyCollection<T> — не копирует данные; изменения в оригинальном списке видны в read-only view.
ToArray() создаёт новый массив и копирует элементы — безопасно для snapshot.

Версионирование и перечислитель

List<T> отслеживает _version. Если список изменён во время foreach, Enumerator бросит InvalidOperationException (fail-fast). → Правильный способ изменения во время перебора: собирать для удаления в отдельный список или итерировать по копии, или использовать цикл for (по индексам) и итерировать назад при удалении.

Статические поля per-closed-type

У generic-класса статические поля — отдельны для каждого конкретного T (например, List<int> и List<string> — свои статические поля).

Boxing и value-types

List<T> при T = value type (например, int) хранит значения без бокcинга — выгодно по проивзодительности по сравнению с ArrayList/List<object>.
Но будьте внимательны: при приведении к не-generic интерфейсам (например, IList) могут возникать бокcинги.

Enumerator как struct (подводные камни)

List<T>.Enumerator — struct, поэтому foreach по List<T> обычно не вызывает аллокаций. Но:
- Если вы присваиваете список переменной типа IEnumerable<T>/IEnumerable, компилятор вызывая интерфейсную GetEnumerator может привести к бокcингу enumerator’а (или использовать интерфейсную реализацию), что создаёт аллокацию.
- При debug/ToString и пр. тоже можно получить накладные расходы.

📈 Сложности (Big-O) — быстро

Операция	Средняя/аморт.	Худшая
`Add`	O(1) амортизировано	O(n) (при ресайзе)
`Insert` (в середину)	O(n)	O(n)
`Remove` (по значению)	O(n)	O(n)
`RemoveAt`	O(n) (сдвиг)	O(n)
`IndexOf` / `Contains`	O(n)	O(n)
`this[i]` (get/set)	O(1)	O(1)
`BinarySearch`	O(log n)	O(log n)
`Sort`	O(n log n)	O(n log n)
`ToArray`	O(n)	O(n)
`AddRange` (из ICollection)	O(k) (кратное)	O(n) (перералокация)

🧨 Частые подводные камни / собес-ловушки (и как отвечать)

1) «Что делает `Capacity`?»

Коротко: это длина внутреннего массива; Count — реальное число элементов. Capacity >= Count. Установка Capacity < Count — ошибка.

2) «Почему `Add` не всегда O(1)?»

Потому что при заполнении буфера требуется перераспределение и копирование → одна операция может быть O(n), но серия добавлений амортизированно O(1).

3) «Можно ли безопасно удалять элементы в `foreach`?»

Нет — перечислитель проверки версии и бросит InvalidOperationException. Решение: итерировать по индексу (в обратном порядке при удалении) или собирать список удаляемых элементов и удалить их после.

4) «List.Sort — стабильный?»

Sort не гарантирует стабильность. Если нужна стабильная сортировка — используйте OrderBy/ThenBy (LINQ) или реализуйте стабильный алгоритм.

5) «Почему `List<T>` быстрее `LinkedList<T>` для перебора?»

Потому что элементы в List<T> хранятся подряд → лучшая кэш-локальность → меньше промахов кэша → быстрее в реальности.

6) «Чем `List<T>` отличается от `IList<T>`?»

IList<T> — интерфейс (контракт), List<T> — реализация этого контракта. Интерфейс не гарантирует конкретную сложность операций.

7) «Как избежать бокcинга при хранении value-type?»

Используйте List<T> с конкретным value type (List<int>), не List<object>. Но при приведении к non-generic интерфейсу бокcинг всё равно возможен.

8) «Если нужно быстрый поиск по ключу — использовать `List<T>`?»

Нет. Для быстрых поисков — Dictionary/HashSet (хеш) или SortedDictionary (логарифм) — гораздо эффективнее.

9) «Как уменьшить аллокации при массовом добавлении?»

Перед вызовом Add в цикле вызовите list.Capacity = expectedCount или используйте new List<T>(expectedCount) или AddRange с ICollection<T>.

10) «Что делает `ToArray()` vs `AsReadOnly()`?»

ToArray() — копирует данные в новый массив (snapshot).
AsReadOnly() — возвращает оболочку; изменения в исходном списке отражаются в представлении.

🔧 Полезные практические приёмы и рекомендации

Если знаешь число элементов заранее — создавай new List<T>(capacity) (избежишь ресайзов).
Для частой конкатенации/строк — StringBuilder (аналогичная идея: не создавать много временных объектов).
Для массовых вставок — AddRange быстрее, чем последовательные Add.
Для удаления по предикату — RemoveAll(predicate) (реализация оптимизирована).
При необходимости многопоточного доступа — используйте lock(list) или ConcurrentCollection.
При хранении больших value types — подумай о ref struct/Span<T> или хранении ссылок, чтобы избежать «дорогого копирования».

✅ Вопросы на собесе (типовые) + краткие ответы

Что такое Capacity и чем отличается от Count? Count — текущее число элементов; Capacity — размер внутреннего массива. Capacity ≥ Count.
Почему Add амортизированное O(1)? Потому что рост буфера выполняется редко (обычно удваивание), и суммарная стоимость n добавлений = O(n).
Можно ли безопасно модифицировать List в foreach? Нет — будет InvalidOperationException. Итерируйтесь индексно или делайте копию.
List<T> или LinkedList<T> — что выбрать? Если нужен быстрый доступ по индексу и лучшие характеристики при последовательном обходе — List<T>. Если часто вставляете/удаляете элементы, имея ссылку на узел — LinkedList<T>.
Как уменьшить количество аллокаций при заполнении? Используйте конструктор с capacity, AddRange, или установите Capacity.
**List.Sort — стабильная сортировка?** Нет, стабильность не гарантируется. Для стабильности используйте `OrderBy`.
Что делает TrimExcess()? Ставит Capacity ближе к Count (освобождает неиспользуемую память), может вызвать копирование.
Отличие ToArray() и AsReadOnly()? ToArray() — копия; AsReadOnly() — read-only view поверх текущих данных.
Как List<T> хранит struct? Значения хранятся inline в массиве T[] — без бокcинга. Но при передаче в IList может быть бокcинг.
Перечислитель List<T> — это класс или структура? Это struct — обычно без аллокаций при foreach, но может бокситься при использовании интерфейса.

🔬 Примеры кода — типичные кейсы и ловушки

Удаление элементов во время перебора — неправильно:

foreach (var item in list) // InvalidOperationException если изменили list
{
    if (ShouldRemove(item)) list.Remove(item);
}

Правильно — итерировать назад по index:

for (int i = list.Count - 1; i >= 0; i--)
{
    if (ShouldRemove(list[i])) list.RemoveAt(i);
}

Переход к capacity заранее:

var list = new List<int>(expectedCount);
for (...) list.Add(x);

Добавление коллекции эффективно:

if (source is ICollection<T> coll)
{
    list.Capacity = list.Count + coll.Count;
    // потом копирование, избежание множественных ресайзов
}
else
{
    list.AddRange(source);
}

✨ Резюме — что обязательно знать (шпаргалка для собеса)

List<T> = динамический массив (T[]) + автоматическое расширение.
Count vs Capacity. Add амортизированное O(1), вставки в середину — O(n).
Перечислитель — struct (обычно без allocations), но модификация во время перечисления — исключение.
Для быстрых поисков по ключу — не List<T>, а Dictionary/HashSet.
Для частых вставок/удалений в середине — LinkedList<T> может быть лучше по алгоритмической сложности, но у List<T> лучше кэш-локальность.
Используйте new List<T>(capacity)/AddRange/ToArray/TrimExcess разумно.

⬆ Вернуться к главной

✨Dvurechensky✨

Коллекция вопросов ❓ на собеседовании в C# 🍧

📋 Чем `List'T'` отличается от других коллекций?

✨ Оглавление

🔑 Коротко — что такое List<T>

🧩 Основные характеристики List<T>

🧠 В чём преимущества List<T> перед другими коллекциями

Против T[] (статический массив)

Против LinkedList<T>

Против Queue<T> / Stack<T>

Против HashSet<T> / Dictionary<TKey,TValue>

Против SortedSet<T> / SortedDictionary<TKey,TValue>

Против ObservableCollection<T> / ReadOnlyCollection<T>

Против ConcurrentBag/Queue/Dictionary

Против ImmutableList<T> (immutable collections)