Когда вы впервые учитесь кодировать, общепринято изучать массивы в качестве «основной структуры данных».

В конце концов, вы также изучаете хэш-таблицы. Для получения степени по «Компьютерным наукам» (Computer Science) вам придется походить на занятия по структурам данных, на которых вы узнаете о связанных списках, очередях и стеках. Эти структуры данных называются «линейными», поскольку они имеют логические начало и завершение.

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

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

Из этой статьи вы узнаете:

  • Что такое деревья?
  • Разберете примеры деревьев.
  • Узнаете терминологию и разберете алгоритмы работы с этими структурами.
  • Узнаете как реализовать древовидные структуры в программном коде.

Давайте начнем наше учебное путешествие 🙂

Определения

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

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

Давайте вплотную займемся реальными примерами

Что я имею в виду, когда я говорю иерархически?

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

Мое фамильное дерево

Приведенный рисунок – это мое фамильное древо. Тосико, Акикадзу, Хитоми и Такеми – мои дедушки и бабушки.

Тошиаки и Джулиана – мои родители.

ТК, Юдзи, Бруно и Кайо – дети моих родителей (я и мои братья).

Структура организации – еще один пример иерархии.

Структура компании является примером иерархии

В HTML, объектная модель документа (DOM) представляется в виде дерева.

Объектная модель документа (DOM)

HTML-тег содержит другие теги. У нас есть тег заголовка и тег тела. Эти теги содержат определенные элементы. Заголовок имеет мета теги и теги заголовка. Тег тела имеет элементы, которые отображаются в пользовательском интерфейсе, например,  h1aliи т.д.

Техническое определение

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

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

Все узлы дерева соединены линиями, называемыми ребрами. Это важная часть деревьев, потому что она управляет связью между узлами.

Листья — это последние узлы на дереве. Это узлы без потомков. Как и в реальных деревьях, здесь имеется корень, ветви и, наконец, листья.

Другими важными понятиями являются высота и глубина.

Высота дерева — это длина самого длинного пути к листу.

Глубина узла — это длина пути к его корню.

Справочник терминов

  • Корень – самый верхний узел дерева.
  • Ребро – связь между двумя узлами.
  • Потомок – узел, имеющий родительский узел.
  • Родитель – узел, имеющий ребро, соединяющее его с узлом-потомком.
  • Лист – узел, не имеющий узлов-потомков на дереве.
  • Высота – это длина самого дальнего пути к листу.
  • Глубина – длина пути к корню.

Бинарные деревья

Теперь рассмотрим особый тип деревьев, называемых бинарными или двоичными деревьями.

Рассмотрим пример бинарного дерева.

Давайте закодируем бинарное дерево

Первое, что нам нужно иметь в виду, когда мы реализуем двоичное дерево, состоит в том, что это набор узлов. Каждый узел имеет три атрибута: value, left_child, и right_child.

Как мы реализуем простое двоичное дерево, которое инициализирует эти три свойства?

Давайте посмотрим.

Вот наш двоичный класс дерева.

Когда мы создаем экземпляр объекта, мы передаем значение (данные узла) в качестве параметра. Посмотрите на  left_child, и  right_child. Оба имеют значение None.

Почему?

Когда мы создаем наш узел, он не имеет потомков. Просто есть данные узла.

Давайте это проверим:

Это выглядит так.

Мы можем передать строку  ‘a’  в качестве значения нашему узлу бинарного дерева. Если мы напечатаем значение,  left_child и  right_child, мы увидим значения.

Перейдем к части вставки. Что нам нужно здесь сделать?

Мы реализуем метод вставки нового узла справа и слева.

Вот правила:

  • Если у текущего узла нет левого дочернего элемента, мы просто создаем новый узел и устанавливаем его в left_child текущего узла.
  • Если у него есть левый дочерний потомок, мы создаем новый узел и помещаем его вместо текущего левого потомка. Назначьте этот левый дочерний узел новым левым дочерним новым узлом.

Давайте это нарисуем 🙂

Вот программный код:

Еще раз, если текущий узел не имеет левого дочернего элемента, мы просто создаем новый узел и устанавливаем его в качестве left_child текущего узла. Или мы создаем новый узел и помещаем его вместо текущего левого потомка. Назначим этот левый дочерний узел в качестве левого дочернего элемента нового узла.

И мы делаем то же самое, чтобы вставить правый дочерний узел.

Сделано. 🙂

Но не полностью. Осталось протестировать.

Давайте построим следующее дерево:

Подытоживая изображенное дерево, заметим:

  • узел a будет корнем нашего бинарного дерева
  • левым потомком a является узел b
  • правым потомком a является узел c
  • правым потомком b является узел d (узел b не имеет левого потомка)
  • левым потомком c является узел  e
  • правым потомком c является узел f
  • оба узла e и f не имеют потомков

Таким образом, вот код для нашего дерева следующий:

Вставка выполнена.

Теперь нам нужно подумать об обходе дерева.

У нас есть два варианта: поиск в глубину (DFS) и поиск по ширине (BFS).

•    Поиск в глубину (Depth-first search, DFS) — один из методов обхода дерева. Стратегия поиска в глубину, как и следует из названия, состоит в том, чтобы идти «вглубь» дерева, насколько это возможно. Алгоритм поиска описывается рекурсивно: перебираем все исходящие из рассматриваемой вершины рёбра. Если ребро ведёт в вершину, которая не была рассмотрена ранее, то запускаем алгоритм от этой нерассмотренной вершины, а после возвращаемся и продолжаем перебирать рёбра. Возврат происходит в том случае, если в рассматриваемой вершине не осталось рёбер, которые ведут в не рассмотренную вершину. Если после завершения алгоритма не все вершины были рассмотрены, то необходимо запустить алгоритм от одной из не рассмотренных вершин.

•    Поиск в ширину (breadth-first search, BFS) — метод обхода дерева и поиска пути. Поиск в ширину является одним из неинформированных алгоритмов поиска. Поиск в ширину работает путём последовательного просмотра отдельных уровней дерева, начиная с узла-источника. Рассмотрим все рёбра, выходящие из узла. Если очередной узел является целевым узлом, то поиск завершается; в противном случае узел добавляется в очередь. После того, как будут проверены все рёбра, выходящие из узла, из очереди извлекается следующий узел, и процесс повторяется.

Давайте подробно рассмотрим каждый из алгоритмов обхода.

Поиск в глубину (DFS)

DFS исследует все возможные пути вплоть до некоторого листа дерева, возвращается и исследует другой путь (осуществляя, таким образом, поиск с возвратом). Давайте посмотрим на пример с этим типом обхода.

Результатом этого алгоритма будет: 1–2–3–4–5–6–7.

Почему?

Давайте разъясним это подробно.

  1. Начать с корня (1). Записать.
  2. Перейти к левому потомку (2). Записать.
  3. Затем перейти к левому потомку (3). Записать. (Этот узел не имеет потомков)
  4. Возврат и переход к правому потомку (4). Записать. (Этот узел не имеет потомков)
  5. Возврат к  корневому узлу и переход к правому потомку (5). Записать.
  6. Переход к левому потомку (6). Записать. (Этот узел не имеет никаких потоков)
  7. Возврат и переход к правому потомку (7). Записать. (Этот узел не имеет никаких потомков)
  8. Выполнено.

Проход в глубь дерева, а затем возврат к исходной точке называется алгоритмом DFS.

После знакомства с этим алгоритмом обхода, рассмотрим различные типы DFS-алгоритма: предварительный обход (pre-order), симметричный обход (in-order) и обход в обратном порядке (post-order).

Предварительный обход

Именно это мы и делали в вышеприведенном примере.

1.  Записать значение узла.

2.  Перейти к левому потомку и записать его. Это выполняется тогда и только тогда, когда имеется левый потомок.

3.  Перейти к правому потомку и записать его. Это выполняется тогда и только тогда, когда имеется правый потомок.

Симметричный обход

Результатом алгоритма симметричного обхода для этого дерева tree в примере является 3–2–4–1–6–5–7.

Первый левый, средний второй и правый последний.

Теперь давайте напишем программный код.

  1. Перейти к левому потомку и записать. Это выполняется тогда и только тогда, когда имеется левый потомок.
  2. Записать значение узла.
  3. Перейти к правому потомку и записать. Это выполняется тогда и только тогда, когда имеется правый потомок.

Обход в обратном порядке

Результатом алгоритма прохода в обратном порядке для этого примера дерева является 3–4–2–6–7–5–1.

Первое левое, правое второе и последнее посередине.

Давайте напишем для него программный код.

  1. к левому потомку и записать. Это выполняется тогда и только тогда, когда имеется левый потомок.
  2. Перейти к правому потомку и записать. Это выполняется тогда и только тогда, когда имеется правый потомок.
  3. Записать значение узла.

Поиск в ширину (BFS)

BFS алгоритм обходит дерево tree уровень за уровнем вглубь дерева.

Вот пример, помогающий лучше объяснить этот алгоритм:

Таким образом мы обходим дерево уровень за уровнем. В этом примере результатом является 1–2–5–3–4–6–7.

  • Уровень/Глубина 0: только узел со значением 1.
  • Уровень/Глубина 1: узлы со значениями 2 и 5.
  • Уровень/Глубина 2: узлы со значениями 3, 4, 6, и 7.

Теперь давайте напишем программный код.

Для реализации BFS-алгоритма мы используем данные структуры «очередь«.

Как это работает?

Вот пошаговое объяснение.

  1.  Сначала добавитьroot узел внутрь очереди с помощью метода  put.
  2. Повторять до тех пор пока очередь не пуста.
  3. Получить первый узел в очереди, а затем записать ее значение.
  4. Добавить и левый и правый потомок в очередь (если текущий узел имеет потомка).
  5. Выполнено. Мы будет записывать значение каждого узла, уровень за уровнем с помощью нашей очереди.

Бинарное дерево поиска

Важным свойством поиска на двоичном дереве является то, что величина узла Binary Search Tree больше, чем количество его потомков левого элемента-потомка, но меньшее, чем количество его потомков правого элемента-потомка.

Вот детальный разбор приведенной выше иллюстрации.

  • инвертировано. Поддерево subtree 7–5–8–6 должно быть с правой стороны, а поддеревоsubtree 2–1–3 должно быть слева.
  • B является единственной корректной опцией. Оно удовлетворяет свойству Binary Search Tree.
  • C имеет одну проблему: узел со значением 4. Он должен быть слева отrootпотому что меньше 5.

Давайте напишем код для поиска на бинарном дереве!

Наступило время писать код!

Что вы увидите? Мы вставим новые узлы, поищем значения, удалим узлы и сбалансируем дерево.

Давайте приступим.

Вставка: добавление новых узлов на наше дерево

Представьте, что у нас есть пустое дерево, и мы хотим добавить новые узлы со следующими значениями в следующем порядке: 50, 76, 21, 4, 32, 100, 64, 52.

Первое, что нам нужно знать, это то, что 50 является корнем нашего дерева.

Теперь мы можем начать вставлять узел за узлом.

  • 76 больше чем 50, поэтому вставим 76 справа.
  • 21 меньше чем 50, поэтому вставим 21 слева.
  • 4 меньше чем 50. Узел со значением 50 имеет левого потомка 21. Поскольку 4 меньше чем 21, вставим его слева от этого узла.
  • 32 меньше чем 50. Узел со значением 50 имеет левого потомка 21. Поскольку 32 больше чем 21, вставим 32 справа от этого узла.
  • 100 больше чем 50. Узел со значением 50 имеет правого потомка 76. Поскольку 100 больше чем 76, вставим 100 справа от этого узла node.
  • 64 больше чем 50. Узел со значением 50 имеет правого потомка 76. Поскольку 64 меньше чем 76, вставим 64 слева от этого узла.
  • 52 больше чем 50. Узел со значением 50 имеет правого потомка 76. Поскольку 52 меньше чем 76, узел со значением 76 имеет левого потомка 64. 52 меньше чем 64, поэтому вставим 54 слева от этого узла.
    Вы заметили, что здесь присутствует некоторая структура (патттерн)?Давайте рассмотрим еще раз более подробно.

    1. В новом узле значение больше или меньше чем значение текущего узла?
    2. Если значение нового узла больше чем значение текущего узла, следует перейти на правое поддерево. Если текущий узел не имеет потомка справа, вставить его справа, или в ином случае вернуться к шагу 1.
    3. Если значение нового узла меньше текущего узла — перейти на левое поддерево. Если текущий узел не имеет левого потомка, вставить его слева, или в ином случае вернуться к шагу 1.
    4. Мы не рассматривали здесь обработку особых ситуаций. Когда значение нового узла равно значению текущего узла, используется правило 3. Рассмотрим вставку равных значений слева в поддерево.

    Давайте напишем программный код.

Вроде бы все просто.

Большой частью этого алгоритма выступает рекурсия, которая находится в строке 9 и строке 13. Обе строки кода вызывают метод  insert_node и используют его для своих левых и правых потомков соответственно.

Строки 11 и 15 осуществляют делают вставку для каждого потомка.

Давайте найдем значение узла … Или не найдем …

Теперь алгоритм, который мы будем строить — алгоритм поиска. Для данного значения (целое число), мы скажем, имеет ли наше дерево двоичного поиска или нет это значение.

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

Давайте рассмотрим пример.

Представьте, что у нас имеется это дерево.

Теперь мы хотим узнать есть ли у нас узел со значением 52.

Давайте рассмотрим подробнее.

  1. Начинаем с корневого узла в качестве текущего. Является ли данная величина меньше текущей величины узла? Если да, будем искать ее на поддереве слева.
  2. Данное значение больше текущего значения для узла? Если да, будем искать ее справа на поддереве.
  3. Если правила №1 и №2 оба неверны, можем сравнить значение текущего узла и заданного узла на равенство. Если результат сравнения выдает значение  true, можем сказать, «Да!» Наше дерево имеет заданное значение, иначе сказать – нет, оно не имеет.

Давайте напишем код.

Разберем код подробнее:

  • Строки 8 и 9 попадают под правило №1.
  • Строки 10 и 11 попадают под правило №2.
  • Строки 13 попадают под правило №3.

Как нам это проверить?

Давайте создадим наше Binary Search Tree путем инициализации корневого узла значением 15.

А теперь мы вставим много новых узлов.

Для каждого вставленного узла мы проверим работает ли наш метод find_node.

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

О да.

Поиск выполнен.

Стирание: удаление и организация

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

  • Сценарий №1: узел без потомков (листовой узел).

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

  • Сценарий №2: узел с одним потомком (левый или правый потомок).

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

  • Сценарий №3: узел с двумя потомками.

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

Пришло время записать код.

  1. Во-первых: Обратите внимание на значение параметров и родительский. Мы хотим найти узел, который имеет это значение, а родительский узел имеет важное значение для удаления узла.
  2. Во-вторых: Обратите внимание на возвращаемое значение. Наш алгоритм вернет логическое значение. Он возвращает True, если находит узел и удаляет его. В противном случае он вернет False
  3. От строки 2 до строки 9: Мы начинаем искать узел, который имеет искомое значение. Если значение меньше текущего значения узла, мы переходим к левому поддереву, рекурсивно (если и только если текущий узел имеет левый дочерний элемент). Если значение больше ‑ перейти в правое поддерево, повторить.
  4. Строка 10: Начинаем продумывать алгоритм удаления.
  5. От строки 11 до строки 13: Мы покрываем узел без потомков, и это левый потомок его родителя. Мы удаляем узел, устанавливая левый дочерний элемент родителя в None.
  6. Строки 14 и 15: Мы покрываем узел без потомков, и это правый потомок его родителя. Мы удаляем узел, установив правый дочерний элемент родителя в  None.
  7. Очистить метод узла: я покажу код clear_node ниже. Он устанавливает дочерние элементы слева, правый дочерний элемент и его значение в None.
  8. От строки 16 до строки 18: мы покрываем узел только одним потомком (левым дочерним), и это левый потомок его родителя. Мы заменяем левый дочерний элемент родителя на левый дочерний элемент узла (единственный его дочерний элемент).
  9. От строки 19 до строки 21: мы покрываем узел только одним потомком (левым дочерним), и это правый потомок его родителя. Мы устанавливаем правый дочерний элемент родителя в левый дочерний элемент узла (единственный его дочерний элемент).
  10. От строки 22 до строки 24: мы покрываем узел только одним потомком (правый ребенок), и это левый дочерний элемент его родителя. Мы устанавливаем левый дочерний элемент родителя правым дочерним элементом узла (единственный его дочерний элемент).
  11. От строки 25 до строки 27: Мы покрываем узел только одним дочерним элементом (правый дочерний элемент), и это правый потомок его родителя. Устанавливаем правый дочерний элемент родителя правым дочерним элементом узла (единственный его дочерний элемент).
  12. От строки 28 до строки 30: Мы покрываем узел как левыми, так и правыми потомками. Получаем узел с наименьшим значением (код показан ниже) и устанавливаем его на значение текущего узла. Завершите действия, удалив наименьший узел.
  13. Строка 32: если мы найдем узел, который ищем, ему нужно снова присвоить True. Код между строками 11 и 31 мы используем именно для этого случая. Так что просто верните значение True, этого будет достаточно.
  • Чтобы использовать метод clear_node : установите значение None для всех трех атрибутов — (значения  left_child и  right_child)
  • Чтобы использовать метод find_minimum_value : перейдите влево. Если мы больше не найдем узлов, мы найдем самый маленький.

Теперь давайте проверим.

Будем использовать это дерево для проверки нашего алгоритма  remove_node.

Удалим узел со значением 8. Это узел без дочернего элемента.

Теперь давайте удалим узел со значением 17. Это узел с одним потомком.

Наконец, мы удалим узел с двумя потомками. Это корень нашего дерева.

Проверки успешно выполнены 🙂

Пока это все!

Мы с вами уже очень многое изучили.

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

Перевод статьи TK: Everything you need to know about tree data structures