Распродажа

Курс Алгоритмы и структуры данных для C# и Java разработчиков

Реализуйте на C# стек, очередь, дерево и хеш-таблицу сами, а не только пользуйтесь коллекциями .NET

Первоначальная цена составляла 990 грн.Текущая цена: 390 грн.

-60%
Вы экономите: 600 грн (60%)
До конца акции:04дн23час58мин38сек

−20% при покупке от 2 курсов — активируется автоматически

Встроенные коллекции .NET работают, но не показывают, что происходит внутри при добавлении и удалении. Курс строит стек, очередь, списки, деревья, пирамиду и хеш-таблицы с нуля на C#, проверяет их юнит-тестами и сравнивает с библиотечными аналогами.

  • Реализовать на C# стек, очередь, связный список и двоичное дерево поиска с удалением узла
  • Оценивать временную сложность операций и сравнивать сортировки по устойчивости и памяти
  • Реализовать пирамиду, пирамидальную сортировку и хеш-таблицы с раздельными цепочками и линейным пробированием
Add to Cart
Курс Алгоритмы и структуры данных
Курс Алгоритмы и структуры данных для C# и Java разработчиков
990 грн Первоначальная цена составляла 990 грн.390 грнТекущая цена: 390 грн.
  • 11 часов 49 минут видео
  • 72 урока в 13 модулях
  • Скачивается на компьютер
  • Доступ навсегда, без дедлайнов
  • Сертификат по запросу

Цифровой видеокурс для самостоятельного изучения, без обратной связи с преподавателем. После оплаты курс появится в вашем аккаунте на сайте, а ссылка на материалы придёт на email.

Покупка занимает минуту
  1. Добавляете курс в корзину.
  2. Вводите почту и пароль — это ваш аккаунт, в нём курс будет храниться постоянно.
  3. Оплачиваете любым удобным способом — их больше восьми.
  4. Курс сразу открывается в аккаунте, ссылка дублируется на почту.

Доступ навсегда: вернуться к курсу можно и через год. Вопросы — чат на сайте или info@siluette.com.ua.

Курс ведётся на русском языке: видео и материалы русскоязычные. Украинская версия курса появится позже.

Что вы сможете после курса

  • Реализовать стек и очередь на массиве (в том числе кольцевую) и на связном списке
  • Реализовать символьную таблицу на связном списке и на двух синхронизированных массивах с бинарным поиском
  • Реализовать двоичное дерево поиска с удалением узла в трёх случаях
  • Построить максимальную пирамиду и выполнить на ней пирамидальную сортировку
  • Реализовать сортировки (пузырьковую, выборкой, вставками, Шелла, слиянием, быструю) и линейный и бинарный поиск
  • Сравнивать алгоритмы по устойчивости и памяти, оценивать временную сложность операций и проверять реализации юнит-тестами

Кому подойдёт курс

Пишущим на C# или .NET

Курс объясняет, как устроены структуры данных, которыми вы пользуетесь через коллекции .NET. Каждую структуру курс строит в коде и сравнивает со встроенным аналогом: Stack, Queue, LinkedList и Dictionary.

Изучающим структуры данных и алгоритмы

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

Переходящим от общих понятий к коду

Курс начинается с определений, анализа сложности и псевдокода, а затем переходит к реализациям на C#. Сложность операций разбирается и на самом коде, и на замерах: в уроке по оценке роста время строится на log-log графике по двум замерам.

Курс не подойдёт, если нужны сбалансированные деревья (AVL и красно-чёрные) или графы: в курсе они только упоминаются или не разбираются отдельно. Все реализации написаны на C#, других языков курс не использует.

Как проходит обучение

  • Каждая структура строится с нуля в коде — Понятно, из чего состоит реализация, а не только как вызывать готовый метод
  • Сравнение со встроенными Stack, Queue, LinkedList и Dictionary — Видно, чем учебная реализация отличается от библиотечной и в каких операциях уступает ей
  • Ключевые реализации проверяются юнит-тестами — Результат подтверждается запуском тестов на нескольких наборах данных
  • Замеры времени выполнения классом Stopwatch и log-log график — Оценку сложности можно проверить на практике и спрогнозировать время работы для большего размера входа
  • Домашние задания; для части из них выпущен отдельный урок с разбором решения — Сначала задача решается самостоятельно, затем собственная реализация сверяется с эталонной

Что понадобится

  • Visual Studio с отладчиком, ReSharper и окном Test Explorer
  • C# и среда .NET (.NET Core и .NET Framework); юнит-тесты на NUnit, Microsoft.NET Test SDK и TestAdapter
  • Тестовые файлы с наборами чисел для проверки сортировок и поиска

Почему самому обычно не выходит

Встроенные коллекции скрывают, что происходит внутри: по вызову Add или Remove не видно, сколько элементов сдвигается, где нужен обход всего списка и почему операция ведёт себя именно так. Курс показывает это в коде: сдвиг элементов в символьной таблице на двух массивах, перехеширование кластера при удалении в линейном пробировании, три случая удаления узла из дерева.

Ошибки в таких структурах обычно тонкие. Например, Equals и GetHashCode нужно переопределять вместе, чётный размер массива цепочек плохо распределяет хеши при модулярном хешировании, а замена строгого сравнения в сортировке ломает её устойчивость. Курс разбирает каждый такой случай на примере.

Что изменится

До курса

  • Структуры данных воспринимаются как готовые коллекции, внутри которых непонятно, что происходит
  • Не ясно, почему поиск по ключу в одном случае быстрее, чем в другом
  • Выбор сортировки делается по названию, без понимания устойчивости и памяти
  • Удаление из дерева, пирамиды и хеш-таблицы остаётся непонятным
  • Переопределение Equals и GetHashCode делается без понимания, почему хеш-коды не хранят и не используют как ключи

После курса

  • Каждая структура собрана в коде: стек, очередь, список, дерево, пирамида, хеш-таблица
  • Сложность операций оценивается по коду и по замерам времени на log-log графике
  • Сортировки сравниваются по устойчивости, памяти и временной сложности
  • Понятны три случая удаления из дерева, восстановление пирамиды через sink и перехеширование кластера
  • Понятно, какие методы переопределяются вместе и почему хеш-коды не хранят и не используют как ключи

Как устроен путь

  1. Абстракция Сначала определяются операции и их поведение: что делает стек, очередь или таблица, без привязки к реализации.
  2. Реализация Структура собирается в коде на C# на массиве или на связном списке, а её операции проверяются юнит-тестами.
  3. Замер и сравнение Время операций измеряется классом Stopwatch, результат сравнивается со встроенным аналогом из .NET, а рост времени строится на log-log графике.
  4. Домашнее задание и разбор Часть задач выполняется самостоятельно, затем собственная реализация сверяется с отдельным уроком-решением.

Программа курса

72 урока · 13 модулей · 11 часов 49 минут видео · Разделы идут от определений и анализа сложности к структурам данных, сортировкам, поиску и хешированию.

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

    • Абстрактный тип и структура данных6:45

      Урок разделяет абстрактный тип данных как модель поведения (набор значений и операций) и структуру данных как его конкретную реализацию. На примере стека показано, что один тип может иметь несколько реализаций, например на массиве или на связном списке. Стек описан как коллекция «последним пришёл — первым ушёл» с операциями push, pop, pick, length и empty.

    • Алгоритм, корректность и псевдокод4:52

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

  • Раздел учит оценивать рост времени работы с размером входа: через временную сложность, log-log график по двум замерам и аппроксимацию. Завершается обзором порядков роста и понятием О-большое.

    • Временная сложность15:36

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

    • Строим log-log график. Прогнозируем время работы алгоритма.6:15

      Урок показывает, как по двум замерам на log-log графике найти наклон и записать модель t(n) = a·n³, где константа a подбирается по экспериментальным данным. Модель проверяется на тестовом файле: отклонение от предсказанного времени укладывается в ожидаемое для этой оценки.

    • Аппроксимации7:18

      Урок показывает тильда-аппроксимацию: из функции времени выполнения отбрасываются младшие члены полинома, логарифмический член и константы. Остаётся главный член, который задаёт порядок роста; например, n³/6 − n²/2 + n/3 сводится к n³.

    • Порядок роста8:03

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

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

    • Обзор массивов в C#19:40

      Урок знакомит с созданием, инициализацией и обходом массивов в C#: фиксированный размер, индексация с нуля, тип Array. Разбираются многомерные и зубчатые массивы, а также исключение при выходе за границы массива.

    • Массивы в памяти11:14

      Урок объясняет размещение массивов в памяти: сам массив — ссылочный объект, а его элементы либо хранятся ссылками на объекты в куче, либо лежат непрерывным блоком значений. Рассматриваются стек, управляемая куча, размер ссылки и закрепление массива блоком fixed.

    • Временная сложность операций на массиве8:16

      Урок сравнивает временную сложность базовых операций на массиве: доступа по индексу, добавления, вставки, обновления и удаления. Константное время возможно при известном индексе, а поиск и физическое удаление требуют линейного прохода.

    • Операции на массивах в C#13:12

      Урок показывает, как операции над массивом выглядят в коде на C#: чтение по индексу, линейный поиск, расширение через копирование и удаление. Каждой операции сопоставляется её временная сложность; демонстрационный код лектор не запускает.

  • Раздел проходит пузырьковую сортировку, сортировку выборкой и сортировку вставками в теории и в коде на C#, а также сортировку Шелла (теория), сортировку слиянием (реализация) и быструю сортировку (теория и реализация). Отдельно разбираются устойчивость алгоритма и рекурсия.

    • Пузырьковая сортировка (теория)9:48

      Урок вводит пузырьковую сортировку: соседние элементы попарно сравниваются и меняются местами, когда левый больше правого, а проходы повторяются до неубывающего порядка. Рассматриваются свойства алгоритма: работа на месте (in-place), устойчивость и квадратичная временная сложность.

    • Пузырьковая сортировка (реализация)14:06

      Урок переводит пузырьковую сортировку в код на C#: отдельный метод обмена swap, двойной цикл с сокращающейся границей и проверка юнит-тестом через CollectionAssert.IsOrdered на нескольких наборах входных данных.

    • Устойчивость (стабильность) алгоритма сортировки8:54

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

    • Сортировка выборкой (теория)4:57

      Урок объясняет сортировку выборкой: на каждом проходе находится максимальный элемент и ставится в конец неотсортированной части, граница которой задаётся итератором PartIndex. Разбираются свойства алгоритма: работа на месте, неустойчивость и квадратичная временная сложность.

    • Сортировка выборкой (реализация)5:35

      Урок показывает реализацию сортировки выборкой на C#: внешний цикл уменьшает PartIndex, внутренний цикл ищет индекс максимума largestAt, после чего элемент меняется местами с PartIndex через метод swap. Результат проверяется юнит-тестом SelectionSort.

    • Сортировка вставками (теория)8:59

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

    • Сортировка вставками (реализация)6:12

      Урок показывает реализацию сортировки вставками на C#: метод insertion sort с внешним циклом и внутренним циклом сдвигов назад. Проверка выполняется тестом в Test Explorer, а также разбирается источник квадратичной сложности, то есть большое число сдвигов.

    • Рекурсия15:10

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

    • Сортировка Шелла (теория)14:00

      Урок объясняет сортировку Шелла как развитие сортировки вставками: сначала переставляются элементы, удалённые друг от друга на расстояние gap, затем выполняется обычная вставка при gap, равном единице. Разбираются выбор последовательности gap, временная сложность и неустойчивость алгоритма.

    • Сортировка слияниями (реализация)14:56

      Урок показывает реализацию сортировки слияниями на C#: рекурсивное разбиение массива по границам low и high и слияние половин через вспомогательный массив, выделяемый один раз. Рассматривается защитная проверка, которая пропускает слияние, если части уже упорядочены.

    • Быстрая сортировка (теория)8:12

      Урок знакомит с быстрой сортировкой: массив делится вокруг опорного элемента, после чего рекурсивно обрабатываются части слева и справа. Разбираются работа на месте без дополнительной памяти, средняя и худшая временная сложность, нестабильность и гибрид с пирамидальной сортировкой (интросорт).

    • Быстрая сортировка (реализация)6:58

      Урок показывает реализацию быстрой сортировки на C#: рекурсивную функцию sort с базовым случаем и функцию partition, которая ставит опорный элемент (первый в диапазоне) на окончательное место. Результат проверяется тестом valid input, sorted output.

  • Раздел вводит узел как строительный блок связного списка и различие односвязного и двусвязного вариантов. Разбирается сложность добавления и удаления в начале и в конце, а также устройство LinkedList<T> из .NET.

    • Узел (Node) – базовый строительный блок9:14

      Узел — базовый строительный элемент связанного списка: он хранит данные (примитивные значения или объекты пользовательских типов) и ссылку next на другой узел. По умолчанию ссылка равна null; соединяя узлы присваиванием next, получают цепочку, которую обходят циклом while до null.

    • Связные списки2:04

      Связный список — абстрактный тип данных, который строит цепочку элементов и предоставляет операции добавления, удаления, поиска и обхода. Список хранит ссылки head и tail на края цепочки; в односвязном узле одна ссылка на следующий элемент, в двусвязном — две, на соседей в обе стороны.

    • Односвязный список (теория)8:08

      Узлы односвязного списка связаны указателем next. Вставка в начало и в конец выполняется за константное время, а удаление последнего узла требует обхода от головы, так как предпоследний узел напрямую не доступен. Удаление первого узла сводится к сдвигу головы, отброшенные узлы очищает сборщик мусора.

    • Двусвязный список (теория)3:05

      В двусвязном списке каждый узел хранит ссылки на следующий и предыдущий узлы, поэтому обход возможен в обе стороны. Благодаря ссылке tail на предыдущий узел удаление последнего элемента выполняется за константное время. Цена решения — два указателя на каждый узел вместо одного и более сложное согласованное обновление ссылок при каждой операции; список можно замкнуть в кольцо.

    • Тип LinkedList в BCL8:18

      Тип LinkedList<T> из библиотеки классов .NET — двусвязный кольцевой список: в классе хранится только head, кольцо держится на ссылках next хвоста и previous головы, а свойство Last возвращает предыдущий узел головы. Узел LinkedListNode хранит ссылки на соседей и на сам список; помимо addFirst и addLast есть addBefore и addAfter. Вставка и удаление на концах выполняются за константное время, поиск, копирование и очистка — за линейное.

  • Раздел описывает стек как тип с дисциплиной LIFO и тремя операциями. Разбираются две реализации: на массиве с ростом вдвое и на связном списке, а также сравнение со стеком из .NET.

    • Стек (теория)9:15

      Стек вводится как абстрактный тип данных с дисциплиной LIFO и тремя операциями: push, pop и pick. Сравниваются реализации на массиве и на связанном списке: на массиве push при переполнении может занимать линейное время, а на связанном списке push, pop и pick выполняются за константное время.

    • Реализация стека (на массиве)18:57

      Показана реализация стека на массиве с обобщённым типом: операции push, pop и pick, удвоение ёмкости при заполнении массива и перебор элементов через IEnumerable без их удаления. Проверка идёт заранее подготовленными тестами.

    • Реализация стека (на связном списке)6:34

      Показана реализация стека на односвязном списке: push и pop сводятся к addFirst и removeFirst, поэтому собственная логика хранения не нужна. Тесты от варианта на массиве проходят без изменений, достаточно заменить имя типа.

    • Стек из BCL. Характеристики стека5:09

      Разбирается встроенный стек .NET из System.Collections.Generic: его интерфейс совпадает с учебными реализациями, а основан он на массиве. Показано, какие операции выполняются за константное время (Peek, Pop, Push), а какие за линейное (поиск, CopyTo, Clear, TrimAccess).

  • Раздел описывает очередь по принципу FIFO и показывает, почему реализация на массиве с индексами head и tail тратит память впустую. Реализуются очередь на массиве с расширением, кольцевая очередь и очередь на связном списке; затем разбирается Queue из .NET.

    • Очередь (теория)11:49

      Урок вводит очередь как тип данных с принципом FIFO и операциями enqueue, dequeue и пик. Показано, что добавление в массив выполняется за константное время, пока есть свободные слоты, а индексы head и tail только растут, из-за чего память расходуется впустую.

    • Реализация очереди (на массиве)11:01

      Урок показывает реализацию очереди на массиве с индексами head и tail и автоматическим расширением. При заполнении создаётся массив вдвое большего размера, содержимое копируется, а dequeue на пустой очереди бросает InvalidOperationException.

    • Кольцевая очередь (реализация)13:09

      Урок показывает кольцевую очередь на массиве, где индексы переходят в начало массива. Признак переполнения, подсчёт Count, перебор и расширение с двухэтапным копированием учитывают как развёрнутое, так и свёрнутое состояние очереди.

    • Реализация очереди (на связном списке)6:23

      Урок показывает очередь на связном списке, где Enqueue, Dequeue и Pick делегируются списку (AddLast, RemoveFirst и значению головного узла). Класс LinkedQ реализует IEnumerable, но не ICollection, чтобы не поддерживать удаление из середины.

    • Встроенная очередь BCL на кольцевом массиве7:28

      Встроенная очередь BCL — Queue<T> из System.Collections.Generic — построена на кольцевом массиве с растущей ёмкостью. Разобраны коэффициент роста (по умолчанию два, ёмкость растёт минимум на четыре элемента) и стоимость операций: Peek и Dequeue за константное время, Contains, CopyTo, ToArray и Clear за линейное.

  • Раздел разбирает линейный поиск и методы поиска в коллекциях .NET и LINQ, которые работают за линейное время. Бинарный поиск по отсортированному массиву реализуется итеративно и рекурсивно.

    • Линейный поиск22:12

      Урок разбирает линейный поиск: последовательную проверку элементов до совпадения, которую реализуют циклом для массива и для списка объектов с компаратором. Собственные реализации сравниваются с методами Exists, IndexOf, Find, FindLast, FindAll и Where из списков и LINQ; все они работают за линейное время.

    • Бинарный поиск (реализация)12:34

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

  • Раздел описывает символьную таблицу как хранилище данных по ключу и набор методов, общий для всех таблиц. Реализуются последовательный поиск на связном списке с удалением и таблица на двух синхронизированных массивах с бинарным поиском, включая min, max, floor, ceiling и range.

    • Введение в символьные таблицы3:18

      Урок вводит символьные таблицы как структуры, где значение записывается и извлекается по ключу. Рассматриваются встроенные в .NET типы Dictionary, Sorted Dictionary и Sorted List, а также варианты реализации: на связанном списке, на параллельных массивах, на балансируемом дереве и на хэш-таблице.

    • API символьных таблиц7:20

      Урок описывает программный интерфейс символьных таблиц: базовый набор методов (добавление, поиск через tryGet и get, удаление, contains, empty, count, keys) и расширенный набор для упорядоченных таблиц (min, max, floor, ceiling, rank, select, range), которого нет у Dictionary.

    • Последовательный поиск (тривиальный подход)13:25

      Урок показывает реализацию символьной таблицы на односвязном списке с линейным поиском: поиск проходит список от головы и сравнивает ключи компаратором, а добавление создаёт новый узел в начале списка. Такая структура подходит лишь для небольшого объёма данных, так как в худшем случае проверяются все узлы.

    • Последовательный поиск ДЗ1:07

      Урок ставит домашнее задание: самостоятельно реализовать метод remove для таблицы на связанном списке. Метод принимает ключ, запрещает null-ключ, полностью исключает пару из списка, обновляет счётчик и возвращает true или false в зависимости от того, найден ли ключ.

    • Последовательный поиск решение ДЗ6:14

      Урок разбирает решение домашнего задания по remove: защита от null-ключа через ArgumentNullException, особый случай единственного узла, удаление головного узла и удаление из середины или конца списка с перестройкой ссылок через предыдущий и текущий узлы. Тест проекта, ожидающий ArgumentException, требует правки.

    • Символьная таблица на бинарном поиске26:17

      Урок показывает символьную таблицу на двух синхронизированных отсортированных массивах (ключи и значения): поиск по рангу выполняется бинарным поиском, а вставка и удаление сдвигают элементы, поэтому на больших объёмах они медленные. Методы min, max и range остаются домашним заданием.

    • Символьная таблица на бинарном поиске ДЗ5:12

      Урок ставит домашнее задание: реализовать методы, опирающиеся на упорядоченность ключей, — min, max, removeMin, removeMax, select, ceiling, floor и range. Ожидаемые результаты задаются на примере таблицы с ключами от B до F.

    • Символьная таблица на бинарном поиске решение ДЗ11:36

      Урок разбирает решение домашнего задания по методам для упорядоченных ключей. Min и max берут первый и последний ключ массива, removeMin и removeMax используют готовый remove, а ceiling, floor, select и range опираются на rank и проверки аргументов, включая граничные случаи и исключения при пустой таблице или неверном индексе.

  • Раздел объясняет, как хеш-функция превращает ключ в индекс и почему нужны правила для коллизий. Разбирается GetHashCode у значимых и ссылочных типов, реализуются хеш-таблицы с раздельными цепочками и линейным пробированием, затем словарь Dictionary из .NET.

    • Введение в хеш-таблицы5:26

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

    • Хеширование в примитивных типах и GetHashCode12:59

      Урок разбирает, как встроенные типы .NET вычисляют GetHashCode: для int хеш совпадает с самим числом, для bool значение true даёт 1, а false даёт 0. Хеш строки нестабилен между версиями, платформами и запусками, поэтому его не хранят и не используют как ключ. Совпадение хешей не означает равенство объектов, поэтому после совпадения нужно сравнивать их состояние.

    • GetHashCode в ссылочных типах и типах-значениях9:02

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

    • Значимость хеширования. Реализация GetHashCode25:59

      Урок показывает, почему хеш-коды важны для словарей: при переопределении Equals и GetHashCode объекты-ключи сравниваются по содержимому, а не по ссылке. GetHashCode должен учитывать все поля, а объекты-ключи делают неизменяемыми, иначе после изменения поля словарь перестаёт находить запись. Демонстрация идёт на словаре книг и на пользовательских типах: телефонном номере и персоне.

    • Разрешение коллизий6:18

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

    • Метод раздельных цепочек16:42

      Урок показывает сборку хеш-таблицы с раздельными цепочками: индекс вычисляется из хеш-кода, а коллизии разрешаются списками внутри массива. Разобраны методы get, contains, add и remove, а также рост массива при увеличении средней длины цепочек. Поиск внутри каждой цепочки выполняется последовательным перебором.

    • Метод раздельных цепочек ДЗ2:07

      Домашнее задание: сделать размер массива цепочек простым числом, так как чётный размер при модулярном хешировании плохо распределяет хеши. Урок упоминает решето Эратосфена как базовый способ получить простые числа. Результатом должен стать выбор размера массива из простых чисел вместо значений, кратных двум.

    • Метод раздельных цепочек решение ДЗ19:28

      Разбирается решение домашнего задания: ёмкость массива цепочек берётся из заранее составленного списка простых чисел, взятого из реализации Dictionary в BCL, а при его превышении следующее простое вычисляется на лету. Проверка простоты делит кандидата на нечётные делители до квадратного корня. Расширение и сужение ёмкости выполняются по простым числам.

    • Метод линейного пробирования20:15

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

    • Словари в BCL5:38

      Урок объясняет устройство встроенного словаря .NET: хеш-таблицу из массивов buckets и entries, где каждая запись хранит хеш-код, ссылку на следующую запись и пару ключ-значение. Индекс вычисляется из хеш-кода и остатка от деления на размер buckets. Операции по ключу выполняются за константное время, а ContainsValue и Clear за линейное.

  • Раздел вводит дерево как иерархическую структуру и правило упорядочивания двоичного дерева поиска. Реализуются вставка, поиск и обходы дерева, а затем удаление узла в трёх случаях.

    • Введение в деревья5:26

      Урок вводит базовые понятия дерева как иерархической структуры: корень, лист, ребро, поддерево, глубина и высота узла. Дерево рассматривается как частный случай графа без циклов, в котором у каждого узла не более одного родителя.

    • Двоичное дерево поиска (Binary Search Tree – BST)10:09

      Урок задаёт правило двоичного дерева поиска: в левом поддереве узла лежат меньшие значения, в правом — большие или равные. Показано, что порядок вставки влияет на высоту дерева и, как следствие, на скорость поиска; также описаны полное и завершённое деревья.

    • Простая реализация BST. Часть 113:32

      Урок реализует узел дерева с обобщённым значением и рекурсивные методы вставки и поиска. Также перечислены четыре способа обхода дерева: по уровням, in-order, pre-order и post-order.

    • Простая реализация BST. Часть 214:49

      Урок собирает класс двоичного дерева поиска: рекурсивный обход in-order, поиск минимума и максимума, делегирование операций от класса к корневому узлу. Пустое дерево обрабатывается отдельно, а удаление в уроке намеренно не реализуется.

    • Операция удаления в BST (теория)7:54

      Урок разбирает три случая удаления узла из двоичного дерева поиска: лист, узел с одним потомком и узел с двумя потомками. Для последнего описаны две стратегии замены — максимальным узлом левого поддерева или минимальным узлом правого.

    • Операция удаления в BST (реализация)10:15

      Урок показывает код удаления: публичный метод передаёт корень во вспомогательный рекурсивный метод, который возвращает узел поддерева и обрабатывает три случая. Узел с двумя потомками получает значение минимального узла правого поддерева, после чего оно удаляется из правого поддерева.

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

    • Определение пирамиды4:43

      Урок задаёт определение пирамиды как полного бинарного дерева, в котором родители упорядочены относительно потомков. Разбирается различие максимальной и минимальной пирамиды, на примерах сравниваются полные и неполные деревья.

    • Пирамида и массив4:12

      Показано, как хранить максимальную пирамиду в массиве: корень стоит по индексу 0, а индексы потомков и родителя вычисляются арифметически.

    • Операция вставки (теория)2:41

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

    • Реализация пирамиды13:58

      Реализован обобщённый класс максимальной пирамиды на массиве: вставка с удвоением массива при заполнении, метод swim для подъёма элемента и перебор значений до счётчика count.

    • Операция удаления (теория)4:39

      Прямое удаление нарушает свойства пирамиды, поэтому удаляемый узел заменяется последним элементом массива. Затем замещающий элемент поднимается методом swim или опускается методом sink, причём обмен идёт с наибольшим дочерним узлом.

    • Операция удаления (реализация). Реализация Peek.14:50

      Реализованы операция pick, возвращающая корень и выбрасывающая исключение для пустой пирамиды, и remove по индексу с восстановлением через метод sink. Работа pick и remove проверяется на тестовых значениях.

    • Характеристики операций на пирамиде2:10

      Сравниваются временные сложности операций: вставка и удаление выполняются за логарифмическое время, pick за константное, поиск произвольного значения за линейное. Пирамиды оптимизированы под доступ к минимальному и максимальному значениям.

    • Пирамидальная сортировка (теория)8:32

      Набор сначала перестраивается в пирамиду, затем наибольший элемент из корня поочерёдно переносится в конец массива с восстановлением оставшейся части. Сложность составляет n log n во всех случаях, алгоритм работает in-place и является неустойчивым.

    • Пирамидальная сортировка (реализация)5:29

      Сортировка собрана в одном методе Sort из уже написанных блоков: корень переносится в конец, граница пирамиды сокращается на единицу, а восстановление через утопление корня выполняется с передачей границы параметром. Результат проверяется на тестовом наборе значений в порядке возрастания.

  • Раздел разбирает решето Эратосфена для поиска всех простых чисел до заданного предела. Реализация на C# построена на yield return; в курсе этот механизм не разбирается подробно.

    • Решето Эратосфена13:02

      Урок разбирает решето Эратосфена — способ найти все простые числа до заданного n, последовательно отсеивая составные. Показана реализация на C#: метод sieve возвращает числа через yield return, то есть вычисляет их по запросу, а клиентский код получает их через foreach.

Частые вопросы

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

Об этом курсе

  • Курс рассчитан на тех, кто пишет на C# или изучает его в среде .NET. Вводные уроки начинаются с понятий абстрактного типа данных, алгоритма и сложности, поэтому они подходят и тем, кто переходит от общих понятий к коду.

  • Каждую структуру курс строит с нуля и сравнивает со встроенным аналогом библиотеки .NET: Stack, Queue, LinkedList и Dictionary. Сложность операций разбирается на коде и на замерах времени.

  • Ключевые реализации проверяются юнит-тестами на NUnit. Для сортировок и поиска используются тестовые файлы с наборами чисел, и результат проверяется на нескольких наборах данных.

  • Нет. Сбалансированные деревья в курсе упоминаются как следующий шаг, но не разбираются. Двоичное дерево поиска и удаление узла из него разбираются подробно.

  • Графы отдельным разделом не разбираются: дерево показано как частный случай графа без циклов. Криптография упоминается в связи с простыми числами, но выходит за рамки курса.

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

Доступ и материалы

  • Сразу после оплаты, в ту же секунду и автоматически. Ждать подтверждения не нужно. Доступ приходит двумя путями сразу. Первый: на почту, указанную при оформлении заказа, приходит письмо со ссылкой на материалы. Второй: та же ссылка появляется в вашем аккаунте на сайте, в разделе «Загрузки», и остаётся там постоянно.

  • Все видео и дополнительные файлы лежат в облачном хранилище. Ссылка на него — в вашем аккаунте на сайте, раздел «Загрузки», и в письме, которое пришло после оплаты. Аккаунт здесь — не формальность, а способ доставки: курс остаётся в нём навсегда. Даже если письмо потерялось или вы вспомнили о покупке через год, ссылка будет на месте.

  • Скачивать можно и нужно. Мы рекомендуем сохранить видео на компьютер и смотреть оттуда. Причина простая: облачное хранилище не рассчитано на просмотр видео. Иногда оно позволяет включить ролик прямо в браузере, но качество при этом заметно хуже исходного. На своём компьютере вы увидите курс таким, каким его записывали.

  • Бессрочно. Курс остаётся вашим навсегда, возвращаться к нему можно сколько угодно раз. Если через год или два ссылка вдруг перестанет открываться по техническим причинам — напишите на info@siluette.com.ua, мы её восстановим.

  • Прежде всего: доступ у вас есть в любом случае. Войдите на сайт и откройте раздел «Загрузки» — ссылка на курс уже там, независимо от того, дошло письмо или нет. Чаще всего письмо теряется из-за опечатки в адресе при оформлении заказа. Ещё стоит заглянуть в папку «Спам». Не разбирается — не тратьте время: напишите на info@siluette.com.ua или в чат в правом нижнем углу сайта, мы поможем.

  • Лучше всего на компьютере или ноутбуке: скачайте видео и откройте любым привычным плеером. Понадобятся установленные видеокодеки — на большинстве компьютеров они уже есть. Скачать курс можно на сколько угодно устройств. А вот телефон мы не советуем, и по двум причинам. На маленьком экране плохо видно детали, особенно если в уроке показывают интерфейс программы. И на телефонах часто нет кодеков для форматов, в которых записаны видео.

Оплата и возврат

  • Банковской картой Visa, MasterCard или Prostir, через Google Pay, Apple Pay, Masterpass, Visa Checkout, платёжный QR-код, Botpay в Telegram или Privat24. Есть и оплата частями: Монобанк (3 или 4 платежа), А-Банк (2, 3 или 4 платежа и рассрочка), Банк Глобус (8 платежей), «Скибочка» от OTP Bank (3 платежа), мгновенная рассрочка и оплата частями от ПриватБанка.

  • Да. Платёжная система принимает карты из Евросоюза и любых других стран. Одна деталь, о которой часто забывают: банк может попросить подтвердить платёж — в мобильном приложении или кодом из СМС. Если оплата не проходит, проверьте приложение банка и сообщения.

  • Добавьте в корзину два курса или больше — скидка применится автоматически ко всем товарам в корзине. Два курса: минус 20% на оба. Пять курсов: минус 20% на все пять. Скидка сочетается с любыми акционными ценами и действует на весь каталог без исключений.

  • Цифровые товары возврату и обмену не подлежат. Это общее правило для всех электронных товаров в Украине — постановление Кабинета Министров № 172 от 19 марта 1994 года. При этом мы всегда на связи. Если доступ не открывается, ссылка перестала работать или файлы повреждены — напишите на info@siluette.com.ua, укажите дату и номер заказа. Восстановим. Если что-то непонятно в самом курсе, тоже пишите — подскажем.

  • Пока нет. Мы работаем только с частными покупателями — безналичной оплаты по счёту от юридических лиц сейчас нет.

Как проходит обучение

  • Нет. Все курсы — это записи уроков для самостоятельного изучения: преподаватель не отвечает на вопросы и не проверяет домашние задания. Именно поэтому курсы стоят намного дешевле обучения с куратором. Вы получаете тот же материал, но занимаетесь сами и в своём темпе.

  • Да, цифровой сертификат — по запросу и бесплатно. Напишите на info@siluette.com.ua, укажите имя и фамилию ровно в том виде, в каком хотите видеть их в сертификате, и мы пришлём его в течение суток.

  • Для большинства курсов — нет. Они рассчитаны на начальный уровень и объясняют с азов. Если курс требует подготовки, это сказано в его описании.

  • Нет. Ни дедлайнов, ни расписания, ни сгорающего доступа. Скачали — смотрите когда удобно, с любыми перерывами.

  • Курс покупается для личного использования, и мы просим относиться к этому по-человечески: за каждым уроком стоит работа, а цена и так сильно снижена.

Поддержка

  • Лучше всего на info@siluette.com.ua. Есть и чат в правом нижнем углу сайта, но почта надёжнее: там можно всё описать подробно и приложить скриншоты. Просьба: опишите, что именно вы делали и что пошло не так, и приложите снимок экрана с ошибкой. Так мы решим вопрос сразу, а не будем полдня выяснять, что произошло.

  • В рабочее время, с 9:00 до 19:00, на почту обычно отвечаем в течение часа, в чате — за пару минут. После 19:00 тоже случается, но время ответа не обещаем.

Отзывы покупателей

  1. Андрей

    22.04.2025 Подтвержденный клиент

    Я готовился к собеседованию, и этот курс стал для меня находкой. "Мучили" именно теми алгоритмами, которые разбирали в курсе. Я получил оффер! Огромное спасибо!

  2. Ирина

    30.12.2024 Подтвержденный клиент

    Для тех, кто хочет писать не просто "код", а "эффективный код". Очень рекомендую.

  3. Алена

    27.11.2024 Подтвержденный клиент

    Это база, которую должен знать каждый программист. Наконец-то разобрался, что такое Big-O и как оценивать сложность алгоритмов. Курс все разложил по полочкам.

  4. Екатерина

    26.11.2024 Подтвержденный клиент

    Структуры данных объяснили очень доступно. Списки, стеки, очереди - раньше это был для меня темный лес. Теперь все логично и понятно.

  5. Игорь

    02.03.2024 Подтвержденный клиент

    Все хорошо, но для Java-программиста некоторые моменты, связанные с C# BCL, были не очень актуальны. Но 95% курса - чистый универсальный C.S. Очень полезно.

Показано 5 из 5

Оставить отзыв