Викиконспекты - Вклад участника [ru]

Файл:23treeinsert.png

2015-05-11T21:26:43Z

Flanir1: загружена новая версия «Файл:23treeinsert.png»

Файл:23treeinsert.png

2015-05-11T21:26:22Z

Flanir1: загружена новая версия «Файл:23treeinsert.png»

Файл:23treeinsert.png

2015-05-11T21:26:00Z

Flanir1: загружена новая версия «Файл:23treeinsert.png»

Файл:23treeinsert.png

2015-05-11T21:23:32Z

Flanir1: загружена новая версия «Файл:23treeinsert.png»

Файл:23treeinsert.png

2015-05-11T21:23:10Z

Flanir1: загружена новая версия «Файл:23treeinsert.png»

2-3 дерево

2015-05-11T21:02:33Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{searchNode(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>p</tex> существует, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, следовательно, другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для <tex>p</tex> такие же рассуждения,
*у <tex>gp</tex> оказалось <tex>2</tex> или <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Просто заберем ближайшего к нам сына у <tex>np</tex> и прицепим его к <tex>p</tex>. Восстановим порядок в сыновьях <tex>p</tex>. Теперь у <tex>p</tex> оказалось снова два сына и все узлы 2-3 дерева корректны,
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x):
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
'''if''' (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0]

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508-509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T21:01:46Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{searchNode(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>p</tex> существует, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, следовательно, другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для <tex>p</tex> такие же рассуждения.
*у <tex>gp</tex> оказалось <tex>2</tex> или <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Просто заберем ближайшего к нам сына у <tex>np</tex> и прицепим его к <tex>p</tex>. Восстановим порядок в сыновьях <tex>p</tex>. Теперь у <tex>p</tex> оказалось снова два сына и все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x):
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
'''if''' (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0]

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508-509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:59:59Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{searchNode(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>p</tex> существует, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, следовательно, другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для <tex>p</tex> такие же рассуждения.
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Просто заберем ближайшего к нам сына у <tex>np</tex> и прицепим его к <tex>p</tex>. Восстановим порядок в сыновьях <tex>p</tex>. Теперь у <tex>p</tex> оказалось снова два сына и все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у <tex>gp</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x):
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
'''if''' (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0]

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508-509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:56:22Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{searchNode(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>p</tex> существует, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, следовательно, другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для <tex>p</tex> такие же рассуждения.
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у <tex>gp</tex> оказалось снова два сына и все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у <tex>gp</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
'''if''' (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:55:04Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{searchNode(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>p</tex> существует, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, следовательно, другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для <tex>p</tex> такие же рассуждения.
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у<tex>gp</tex> оказалось снова два сына и все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у <tex>gp</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
'''if''' (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:52:19Z

Flanir1: /* Следующий и предыдущий */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{searchNode(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для <tex>p</tex> такие же рассуждения.
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у<tex>gp</tex> оказалось снова два сына и все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у <tex>gp</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
'''if''' (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:51:52Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{searchNode(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для <tex>p</tex> такие же рассуждения.
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у<tex>gp</tex> оказалось снова два сына и все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у <tex>gp</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:49:34Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел,
*<tex>b</tex> {{---}} брат <tex>t</tex>,
*<tex>p</tex> {{---}} отец <tex>t</tex>,
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>,
*<tex>gp</tex> {{---}} отец <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи (сперва везде удаляем <tex>t</tex>):
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>. Так как у <tex>gp</tex> {{---}} родителя <tex>p</tex>, оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>gp</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у<tex>gp</tex> оказалось снова два сына и все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у <tex>gp</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>gp</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>p</tex>, а у <tex>gp</tex> уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у <tex>gp</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына:
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:38:10Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} брат <tex>t</tex>.
*<tex>p</tex> {{---}} отец <tex>t</tex>.
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, рассмотрим возможные случаи:
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, но у отца <tex>p</tex> не изменим количество детей. Так у отца <tex>p</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>p</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у отца <tex>p</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>p</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>p</tex>):
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:35:46Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} брат <tex>t</tex>.
*<tex>p</tex> {{---}} отец <tex>t</tex>.
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>np</tex>.Рассмотрим возможные случаи:
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, но у отца <tex>p</tex> не изменим количество детей. Так у отца <tex>p</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>p</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у отца <tex>p</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>p</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>t</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>p</tex>):
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:34:34Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} брат <tex>t</tex>.
*<tex>p</tex> {{---}} отец <tex>t</tex>.
*<tex>np</tex> {{---}} соседний брат <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>np</tex>.Рассмотрим возможные случаи:
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, но у отца <tex>p</tex> не изменим количество детей. Так у отца <tex>p</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>p</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у отца <tex>p</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>p</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>p</tex>):
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:28:09Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
*<tex>p</tex> {{---}} отец <tex>t</tex>.
*<tex>np</tex> {{---}} любой брат <tex>p</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>p</tex> уменьшим количество детей.

Если у родителя <tex>t</tex> два сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>np</tex>.Рассмотрим возможные случаи:
*<tex>np</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, но у отца <tex>p</tex> не изменим количество детей. Так у отца <tex>p</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>p</tex> оказалось <tex>2</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>p</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>2</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось три сына, а у отца <tex>p</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>p</tex> оказалось <tex>3</tex> сына, у <tex>np</tex> оказалось <tex>3</tex> сына. Подвесим <tex>b</tex> к <tex>np</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>np</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>p</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>p</tex>):
*Если <tex>np</tex> не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если <tex>np</tex> существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>np</tex>. Теперь у <tex>np</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(np)</tex>. Теперь рекурсивно удалим <tex>p</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:17:02Z

Flanir1: /* Следующий и предыдущий */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>\mathtt{t.parent}</tex> уменьшим количество детей.

Если у родителя <tex>\mathtt{t}</tex> <tex>2</tex> сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>p</tex>. Обозначим отца соседнего листа за <tex>p</tex>.Рассмотрим возможные случаи:
*<tex>p</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, но у отца <tex>\mathtt{t.parent}</tex> не изменим количество детей. Так у отца <tex>\mathtt{t.parent}</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>\mathtt{t.parent}</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось три сына, а у отца <tex>\mathtt{t.parent}</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 3 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>\mathtt{t.parent}</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>\mathtt{t.parent}</tex>):
*Если p не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если p существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>p</tex>. Теперь у <tex>p</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>. Теперь рекурсивно удалим <tex>\mathtt{t.parent}</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:15:35Z

Flanir1:

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>\mathtt{t.parent}</tex> уменьшим количество детей.

Если у родителя <tex>\mathtt{t}</tex> <tex>2</tex> сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>p</tex>. Обозначим отца соседнего листа за <tex>p</tex>.Рассмотрим возможные случаи:
*<tex>p</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, но у отца <tex>\mathtt{t.parent}</tex> не изменим количество детей. Так у отца <tex>\mathtt{t.parent}</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>\mathtt{t.parent}</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось три сына, а у отца <tex>\mathtt{t.parent}</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 3 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>\mathtt{t.parent}</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>\mathtt{t.parent}</tex>):
*Если p не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если p существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>p</tex>. Теперь у <tex>p</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>. Теперь рекурсивно удалим <tex>\mathtt{t.parent}</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != ''null'')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T20:14:41Z

Flanir1: /* Вставка элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else'''
t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = ''null''
t.sons[3] = ''null''
'''if''' (t.parent != ''null'')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != ''null'')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == ''null'')
root = n
'''return'''
Node a = searchNode(x)
'''if''' (a.parent == ''null'')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>\mathtt{t.parent}</tex> уменьшим количество детей.

Если у родителя <tex>\mathtt{t}</tex> <tex>2</tex> сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>p</tex>. Обозначим отца соседнего листа за <tex>p</tex>.Рассмотрим возможные случаи:
*<tex>p</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, но у отца <tex>\mathtt{t.parent}</tex> не изменим количество детей. Так у отца <tex>\mathtt{t.parent}</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>\mathtt{t.parent}</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось три сына, а у отца <tex>\mathtt{t.parent}</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 3 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>\mathtt{t.parent}</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>\mathtt{t.parent}</tex>):
*Если p не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если p существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>p</tex>. Теперь у <tex>p</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>. Теперь рекурсивно удалим <tex>\mathtt{t.parent}</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

Timsort

2015-05-11T20:03:46Z

Flanir1: /* Шаг 1. Вычисление minrun */

'''Timsort''' {{---}} гибридный алгоритм сортировки, сочетающий различные подходы.

Данный алгоритм является относительно новым и был придуман Тимом Петерсом. На массивах данных, которые содержат упорядоченный подмасивы, алгоритм Тима Петерса показывает себя намного лучше других сортировок. В настоящее время '''Timsort''' является стандартной сортировкой в '''Python''' и '''GNU Octave''', реализован в '''OpenJDK 7''' и '''Android JDK 1.5'''.

== Основная идея алгоритма ==
Алгоритм '''Timsort''' состоит из нескольких частей:
* Начало.
* '''Шаг 1'''. Входной массив разделяется на подмассивы фиксированной длины, вычисляемой определённым образом.
* '''Шаг 2'''. Каждый подмассив сортируется [[Сортировка вставками | сортировкой вставками]], [[Сортировка пузырьком | сортировкой пузырьком]] или любой другой устойчивой сортировкой.
* '''Шаг 3'''. Отсортированные подмассивы объединяются в один массив с помощью модифицированной [[Сортировка слиянием | сортировки слиянием]].
* Конец.

Рассмотрим теперь каждый шаг в отдельности.

== Алгоритм ==

=== Обозначения ===

* <tex>n</tex> {{---}} размер входного массива.
* <tex>\mathtt {run}</tex> {{---}} подмассив во входном массиве, который обязан быть упорядоченным одним из двух способов:
** строго по убыванию <tex>\mathtt {a_{i} > a_{i + 1} > \dots} </tex>.
** нестрого по возрастанию <tex>\mathtt {a_{i} \leqslant a_{i + 1} \leqslant \dots} </tex>.
* <tex>\mathtt {minrun} </tex> {{---}} минимальный размер подмассива, описанного в предыдущем пункте.

===Шаг 1. Вычисление minrun===
* Начало.
* '''Шаг 0'''. Число <tex>\mathtt{minrun}</tex> определяется на основе <tex>n</tex>, исходя из следующих принципов:
** Не должно быть слишком большим, поскольку к подмассиву размера <tex>\mathtt{minrun}</tex> будет в дальнейшем применена сортировка вставками (эффективна только на небольших массивах).
** Оно не должно быть слишком маленьким, так как чем меньше подмассив, тем больше итераций слияния подмассивов придётся выполнить на последнем шаге алгоритма. Оптимальная величина для <tex> \mathtt{\dfrac{n}{minrun}} </tex> {{---}} ''степень двойки''. Это требование обусловлено тем, что алгоритм слияния подмассивов наиболее эффективно работает на подмассивах примерно равного размера.
** Автором алгоритма было выбрано оптимальное значение, которое принадлежит диапазону <tex> [32; 65) </tex> (подробнее о том, почему так, будет сказано ниже).
** Исключение: если <tex> n < 64 </tex>, тогда <tex> n = \mathtt{minrun} </tex> и '''Timsort''' превращается в сортировку вставками.
* '''Шаг 1'''. Берем старшие 6 бит числа <tex>n</tex> и добавляем единицу, если в оставшихся младших битах есть хотя бы один ненулевой.

Нетрудно понять, что после таких вычислений, <tex>\mathtt{\dfrac{{n}}{minrun}} </tex> будет степенью двойки.
* Конец.
'''int''' minRunLength(n):
flag = 0 // будет равно 1, если среди сдвинутых битов есть хотя бы один ненулевой
'''while''' (n <tex> \geqslant</tex> 64)
flag |= n & 1
n >>= 1
'''return''' n + flag

===Шаг 2. Алгоритм разбиения на подмассивы и их сортировка===
На данном этапе у нас есть входной массив, его размер <tex>n</tex> и вычисленное число <tex>\mathtt{minrun}</tex>. Обратим внимание, что если данные изначального массива достаточно близки к случайным, то размер упорядоченных подмассивов близок к <tex>\mathtt{minrun}</tex>,. Но если в изначальных данных были упорядоченные диапазоны, то упорядоченные подмассивы могут иметь размер, превышающий <tex>\mathtt{minrun}</tex>. [[Файл:MinrunExample.png‎ |400px|right]]
* Начало.
* '''Шаг 0'''. Указатель текущего элемента ставится в начало входного массива.
* '''Шаг 1'''. Начиная с текущего элемента, идет поиск во входном массиве упорядоченного подмассива <tex>\mathtt{run}</tex>. По определению, в <tex>\mathtt{run}</tex> однозначно войдет текущий элемент и следующий за ним. Если получившийся подмассив упорядочен по убыванию, то после вычисления <tex>\mathtt{run}</tex> для текущего массива элементы переставляются так, чтобы они шли по возрастанию.
* '''Шаг 2'''. Если размер текущего <tex>\mathtt{run}</tex> меньше <tex>\mathtt{minrun}</tex>, тогда выбираются следующие за найденным подмассивом <tex>\mathtt{run}</tex> элементы в количестве <tex> \mathtt{minrun - size(run)} </tex>. Таким образом, на выходе будет получен подмассив размером большим или равный <tex>\mathtt{minrun}</tex>, часть которого (в лучшем случае {{---}} он весь) упорядочена.
* '''Шаг 3'''. К данному подмассиву применяем сортировка вставками. Так как размер подмассива невелик и часть его уже упорядочена {{---}} сортировка работает эффективно.
* '''Шаг 4'''. Указатель текущего элемента ставится на следующий за подмассивом элемент.
* '''Шаг 5'''. Если конец входного массива не достигнут {{---}} переход к шагу 1.
* Конец.

=== Шаг 3. Слияние ===
Нужно объединить полученные подмассивы для получения результирующего упорядоченного массива. Для достижения эффективности, нужно ''объединять подмассивы примерно равного размера'' и ''cохранять стабильность алгоритма''.
[[Файл:Merge2mas.png|400px|right]]
* Начало.
* '''Шаг 0'''. Создается пустой стек пар <tex> < </tex> индекс начала подмассива, размер подмассива <tex> > </tex>.
* '''Шаг 1'''. Берется первый упорядоченный подмассив.
* '''Шаг 2'''. Добавляется в стек пара данных <tex> < </tex> индекс начала текущего подмассива, его размер <tex> > </tex>.
* '''Шаг 3'''. Пусть <tex>X,Y,Z </tex> {{---}} длины верхних трех интервалов, которые лежат в стеке. Причем <tex>X</tex> {{---}} это последний элемент стека.
* '''Шаг 4'''. Повторяем пока выражение (<tex>Z > X + Y \wedge Y > X</tex>) не станет истинным
** Если размер стека не меньше <tex>3</tex> и <tex>Z \leqslant X + Y</tex> {{---}} сливаем <tex>Y</tex> c <tex>\min(X,Z)</tex>.
** Иначе Если <tex>Y \leqslant X </tex> {{---}} сливаем <tex>X</tex> c <tex>Y</tex>.
* '''Шаг 5'''. Если всего осталось <tex> 3 </tex> подмассива, которые сейчас в стеке, то сливаем их в правильном порядке, иначе же переходим к шагу 2.
* Конец

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

===Описание процедуры слияния===
* Начало.

* '''Шаг 0'''. Создается временный массив в размере меньшего из сливаемых подмассивов.

* '''Шаг 1'''. Меньший из подмассивов копируется во временный массив, но надо учесть, что если меньший подмассив {{---}} правый, то ответ (результат сливания) формируется справа налево. Дабы избежать данной путаницы, лучше копировать всегда левый подмассив во временный. На скорости это практически не отразится.

* '''Шаг 2'''. Ставятся указатели текущей позиции на первые элементы большего и временного массива.

* '''Шаг 3'''. На каждом шаге рассматривается значение текущих элементов в большем и временном массивах, берется меньший из них, копируется в новый отсортированный массив. Указатель текущего элемента перемещается в массиве, из которого был взят элемент.

* '''Шаг 4'''. Предыдущий пункт повторяется, пока один из массивов не закончится.

* '''Шаг 5'''.Все элементы оставшегося массива добавляются в конец нового массива.

* Конец.
===Пример===
Возьмем <tex>n = 356</tex>. При таком <tex>n</tex> <tex>\mathtt{minrun}</tex> оказался равным <tex>45</tex>. Ниже представлена работа алгоритма.
Числа с закрывающей скобкой показывают номера шагов, на которых произошло сливание нижестоящих подмассивов.

[[Файл:Example.png|800px]]

== Модификация процедуры слияния подмассивов (Galloping Mode) ==
Рассмотрим процедуру слияния двух массивов:

<tex>A = {1, 2, 3, \dots, 9999, 10000}</tex>

<tex>B = {20000, 20001, 20002, \dots, 29999, 30000}</tex>

Вышеуказанная процедура для них сработает, но каждый раз на её четвёртом пункте нужно будет выполнить одно сравнение и одно копирование. В итоге <tex>10000</tex> сравнений и <tex>10000</tex> копирований. '''Timsort''' предлагает в этом месте модификацию, которая получила называет '''галоп'''. Алгоритм следующий:

* Начало.
* '''Шаг 0'''. Начинается процедура слияния.
* '''Шаг 1'''. На каждой операции копирования элемента из временного или большего подмассива в результирующий запоминается, из какого именно подмассива был элемент.
* '''Шаг 2'''. Если уже некоторое количество элементов (например, в '''JDK 7''' это число равно 7) было взято из одного и того же массива {{---}} предполагается, что и дальше придётся брать данные из него. Чтобы подтвердить эту идею, алгоритм переходит в режим '''галопа''', то есть перемещается по массиву-претенденту на поставку следующей большой порции данных бинарным поиском (массив упорядочен) текущего элемента из второго соединяемого массива.
* '''Шаг 3'''. В момент, когда данные из текущего массива-поставщика больше не подходят (или был достигнут конец массива), данные копируются целиком.
* Конец.
Для вышеописанных массивов <tex>\mathtt{A, B}</tex> алгоритм выглядит следующим образом:
Первые <tex>7</tex> итераций сравниваются числа <tex>1, 2, 3, 4, 5, 6, 7</tex> из массива <tex>A</tex> с числом <tex>20000</tex>, так как <tex>20000</tex> больше, то элементы массива <tex>A</tex> копируются в результирующий. Начиная со следующей итерации алгоритм переходит в режим '''галопа''': сравнивает с числом <tex>20000</tex> последовательно элементы <tex>8, 10, 14, 22, 38, 7+2^{i - 1}, \dots, 10000 </tex> массива <tex>A</tex> <tex>( \thicksim\log{n}</tex> сравнений<tex>)</tex>. После того как конец массива <tex>\mathtt{A}</tex> достигнут и известно, что он весь меньше <tex>B</tex>, нужные данные из массива <tex>A</tex> копируются в результирующий.

== Доказательство времени работы алгоритма ==
Не сложно заметить, что чем меньше массивов, тем меньше произойдёт операций слияния, но чем их длины больше, тем дольше эти слияния будут происходить. На малом количестве длинных массивов хорошо помогает вышеописанный метод '''Galloping Mode'''. Хоть он и не даёт асимптотического выигрыша, но уменьшает константу.
Пусть <tex>k</tex> {{---}} число кусков, на которые разбился наш исходный массив, очевидно <tex>k</tex> = <tex> \left\lceil \mathtt{\dfrac{n}{minrun}} \right\rceil </tex>.

Главный факт, который нам понадобится для доказательства нужной оценки времени работы в <tex>O(n \log{n})</tex> {{---}} это то, что сливаемые массивы '''всегда''' имеют примерно одинаковую длину. Можно сказать больше: пока <tex>k > 3</tex> сливаемые подмассивы будут именно одинаковой длины (данный факт хорошо виден на примере). Безусловно, после разбиения массива на блоки длиной <tex>\mathtt{minrun}</tex> последний блок может быть отличен от данного значения, но число элементов в нём не превосходит константы <tex>\mathtt{minrun}</tex>.

Мы выяснили, что при слиянии, длинна образовавшегося слитого массива увеличивается в <tex>\approx 2</tex> раза. Таким образом получаем, что каждый подмассив <tex>\mathtt{run_i}</tex> может участвовать в не более <tex>O(\log{n})</tex> операций слияния, а значит и каждый элемент будет задействован в сравниниях не более <tex>O(\log{n})</tex> раз. Элементов <tex>n</tex>, откуда получаем оценку в <tex>O(n\log{n})</tex>.

Также нужно сказать про [[Сортировка вставками | сортировку вставками]], которая используется для сортировки подмассивов <tex>\mathrm{run_i}</tex>: в нашем случае, алгоритм работает за <tex>O(\mathtt{minrun + inv})</tex>, где <tex>\mathtt{inv}</tex> {{---}} число обменов элементов входного массива, равное числу инверсий. C учетом значения <tex>k</tex> получим, что сортировка всех блоков может занять <tex>O(\mathtt{minrun + inv}) \cdot k = O(\mathtt{minrun + inv}) \cdot </tex><tex>\left\lceil \mathtt{\dfrac{n}{minrun}} \right\rceil </tex>. Что в худшем случае <tex dpi>(\mathtt{inv = \dfrac{minrun(minrun - 1)}{2}} )</tex> может занимать <tex>O(\mathtt{n \cdot minrun}) </tex> времени. Откуда видно, что константа <tex>\mathtt{minrun}</tex> играет немалое значение: при большом <tex>\mathtt{minrun}</tex> слияний будет меньше, а сортировки вставками будут выполняться долго. Причём эти функции растут с разной скоростью, поэтому и ещё после эксперементов на различных значениях и был выбран оптимальный диапазон {{---}} от <tex>32</tex> до <tex>64</tex>.

==См. также==
* [[Сортировка кучей]]
* [[Быстрая сортировка]]

== Источники информации==
* Peter McIlroy "Optimistic Sorting and Information Theoretic Complexity", Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, ISBN 0-89871-313-7, Chapter 53, pp 467-474, January 1993.

* Magnus Lie Hetland Python Algorithms: Mastering Basic Algorithms in the Python Language. — Apress, 2010. — 336 с.

* [http://ru.wikipedia.org/wiki/Timsort Wikipedia {{---}} Timsort]

* [http://habrahabr.ru/company/infopulse/blog/133303/ Habrahabr {{---}} Алгоритм сортировки Timsort]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Сортировка]]
[[Категория: Сортировки на сравнениях]]

2-3 дерево

2015-05-11T19:49:51Z

Flanir1: /* Следующий и предыдущий */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, a.length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>\mathtt{t.parent}</tex> уменьшим количество детей.

Если у родителя <tex>\mathtt{t}</tex> <tex>2</tex> сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>p</tex>. Обозначим отца соседнего листа за <tex>p</tex>.Рассмотрим возможные случаи:
*<tex>p</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, но у отца <tex>\mathtt{t.parent}</tex> не изменим количество детей. Так у отца <tex>\mathtt{t.parent}</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>\mathtt{t.parent}</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось три сына, а у отца <tex>\mathtt{t.parent}</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 3 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>\mathtt{t.parent}</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>\mathtt{t.parent}</tex>):
*Если p не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если p существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>p</tex>. Теперь у <tex>p</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>. Теперь рекурсивно удалим <tex>\mathtt{t.parent}</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T18:26:54Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, a.length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень (одновременно и единственный элемент в дереве). Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>\mathtt{t.parent}</tex> уменьшим количество детей.

Если у родителя <tex>\mathtt{t}</tex> <tex>2</tex> сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>p</tex>. Обозначим отца соседнего листа за <tex>p</tex>.Рассмотрим возможные случаи:
*<tex>p</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, но у отца <tex>\mathtt{t.parent}</tex> не изменим количество детей. Так у отца <tex>\mathtt{t.parent}</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>\mathtt{t.parent}</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось три сына, а у отца <tex>\mathtt{t.parent}</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 3 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>\mathtt{t.parent}</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>\mathtt{t.parent}</tex>):
*Если p не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если p существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>p</tex>. Теперь у <tex>p</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>. Теперь рекурсивно удалим <tex>\mathtt{t.parent}</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T18:25:29Z

Flanir1: /* Поиск */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t.keys[0]

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 19, оранжевые стрелки обозначают путь по дереву при поиске]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, a.length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>\mathtt{t.parent}</tex> уменьшим количество детей.

Если у родителя <tex>\mathtt{t}</tex> <tex>2</tex> сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>p</tex>. Обозначим отца соседнего листа за <tex>p</tex>.Рассмотрим возможные случаи:
*<tex>p</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, но у отца <tex>\mathtt{t.parent}</tex> не изменим количество детей. Так у отца <tex>\mathtt{t.parent}</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>\mathtt{t.parent}</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось три сына, а у отца <tex>\mathtt{t.parent}</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 3 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>\mathtt{t.parent}</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>\mathtt{t.parent}</tex>):
*Если p не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если p существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>p</tex>. Теперь у <tex>p</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>. Теперь рекурсивно удалим <tex>\mathtt{t.parent}</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-11T18:23:48Z

Flanir1: /* Вставка элемента */

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''2-3 tree'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''T''' search('''T''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else''' '''if''' (t.keys[1] < x)
t = t.sons[2]
'''else''' '''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t.keys[0]
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя, ведь у него тоже могло быть уже <tex>3</tex> сына, а мы разделили и у него стало на <tex>1</tex> сына больше. (перед разделением обновим ключи).

'''function''' splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a = Node(sons = {t.sons[2], t.sons[3]}, keys = {t.keys[2]}, parent = t.parent, a.length = 2)
t.sons[2].parent = a
t.sons[3].parent = a
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' // мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
'''function''' updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) // max {{---}} возвращает максимальное значение в поддереве.
a = a.parent // Примечание: max легко находить, если хранить максимум 
// правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
'''function''' insert('''T''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
*<tex>b</tex> {{---}} любой брат <tex>t</tex>.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него строго больше <tex>2</tex> сыновей, то просто удалим <tex>t</tex>, а у <tex>\mathtt{t.parent}</tex> уменьшим количество детей.

Если у родителя <tex>\mathtt{t}</tex> <tex>2</tex> сына, то найдем у любого соседнего листа его родителя, обозначим его за <tex>p</tex>. Обозначим отца соседнего листа за <tex>p</tex>.Рассмотрим возможные случаи:
*<tex>p</tex> не существует, тогда мы удаляем одного из сыновей корня, тогда другой сын становится новым корнем,
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, но у отца <tex>\mathtt{t.parent}</tex> не изменим количество детей. Так у отца <tex>\mathtt{t.parent}</tex> оказалось тоже два сына,повторяем для него такие же рассуждения.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>2</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то необходимо его расщепить. Теперь у отца <tex>\mathtt{t.parent}</tex> оказалось два сына и все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 2 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось три сына, а у отца <tex>\mathtt{t.parent}</tex> все ещё больше одного сына, то все узлы 2-3 дерева корректны.
*у <tex>\mathtt{t.parent}</tex> оказалось <tex>3</tex> сына, у <tex>p</tex> оказалось 3 сына. Подвесим <tex>b</tex> к <tex>p</tex> и удалим <tex>t</tex>, а у отца уменьшим количество детей. Так как у <tex>p</tex> оказалось четыре сына, то расщепим его, теперь у отца <tex>\mathtt{t.parent}</tex> вновь три сына и все узлы 2-3 дерева корректны.

Обобщим алгоритм при удалении когда у родителя <tex>\mathtt{t}</tex> два сына(ниже мы никогда не уменьшаем количество детей у <tex>\mathtt{t.parent}</tex>):
*Если p не существует, то оказывается, что мы сейчас удаляем какого-то из сыновей корня (для определенности далее левого, с правым аналогично). Тогда теперь правый сын становится корнем. На этом удаление заканчивается.

*Если p существует, то удалим <tex>t</tex>, а его брата (<tex>b</tex>) перецепим к <tex>p</tex>. Теперь у <tex>p</tex> могло оказаться <tex>4</tex> сына, поэтому повторим аналогичные действия из <tex>\mathtt{insert}</tex>: вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>. Теперь рекурсивно удалим <tex>\mathtt{t.parent}</tex>.

В результате мы получаем корректное по структуре 2-3 дерево, но у нас есть нарушение в ключах в узлах, исправим их с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
'''T''' next('''T''' x)
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t.keys[0];

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

Файл:23treesearch.png

2015-05-11T18:19:47Z

Flanir1: загружена новая версия «Файл:23treesearch.png»

Файл:23treesearch.png

2015-05-11T18:19:26Z

Flanir1: загружена новая версия «Файл:23treesearch.png»

2-3 дерево

2015-05-10T21:39:37Z

Flanir1:

[[Файл:23treemain.png|400px|Пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|Поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|Добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|Удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|Путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|Изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:36:30Z

Flanir1: /* Нахождение m следующих элементов */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом: будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:33:37Z

Flanir1: /* Нахождение m следующих элементов */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{delete}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий <tex>\mathtt{next}</tex> и запишем в <tex>\mathtt{next.left}</tex> правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:30:44Z

Flanir1: /* Нахождение m следующих элементов */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> {{---}} добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел. Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:30:25Z

Flanir1: /* Нахождение m следующих элементов */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.

Пусть <tex>t</tex> {{---}} удаляемый узел.

Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:30:00Z

Flanir1: /* Нахождение m следующих элементов */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|изменение ссылок при добавлении нового элемента|thumb|center|800px]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

Файл:23treefindm.png

2015-05-10T21:28:33Z

Flanir1:

2-3 дерево

2015-05-10T21:25:15Z

Flanir1: /* Нахождение m следующих элементов */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefindm.png|thumb|изменение ссылок при добавлении нового элемента|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:18:02Z

Flanir1: /* Источники информации */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} стр. 508 - 509

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:13:00Z

Flanir1: /* Источники информации */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск» {{---}} 508с

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T21:09:18Z

Flanir1: /* Источники информации */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск», т. 3, с. 508

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T20:53:27Z

Flanir1: /* Поиск */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|600px|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск», часть 6.2.4

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

2-3 дерево

2015-05-10T20:52:42Z

Flanir1: /* Поиск */

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|thumb|center|поиск элемента 2]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск», часть 6.2.4

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

Файл:23treesearch.png

2015-05-10T20:46:44Z

Flanir1: загружена новая версия «Файл:23treesearch.png»

Файл:23treesearch.png

2015-05-10T20:46:23Z

Flanir1: загружена новая версия «Файл:23treesearch.png»

2-3 дерево

2015-05-10T20:21:31Z

Flanir1:

[[Файл:23treemain.png|400px|пример 2-3 дерева|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|border]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск», часть 6.2.4

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

Файл:23treemain.png

2015-05-10T20:20:26Z

Flanir1: загружена новая версия «Файл:23treemain.png»

Файл:23treemain.png

2015-05-10T20:20:05Z

Flanir1: загружена новая версия «Файл:23treemain.png»

Файл:23treemain.png

2015-05-10T20:19:43Z

Flanir1: загружена новая версия «Файл:23treemain.png»

2-3 дерево

2015-05-10T20:18:38Z

Flanir1: /* Вставка элемента */

[[Файл:23treemain.png|400px|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|border]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|thumb|center|добавление элемента с ключом 6|600px]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск», часть 6.2.4

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]

Файл:23treeinsert.png

2015-05-10T20:17:14Z

Flanir1: загружена новая версия «Файл:23treeinsert.png»

Файл:23treeinsert.png

2015-05-10T20:16:53Z

Flanir1: загружена новая версия «Файл:23treeinsert.png»

2-3 дерево

2015-05-10T20:15:09Z

Flanir1: /* Удаление элемента */

[[Файл:23treemain.png|400px|thumb]]''' 2-3 дерево '''(англ. ''Heapsort'') — структура данных, представляющая собой сбалансированное дерево поиска, такое что из каждого узла может выходить две или три ветви и глубина всех листьев одинакова. Является частным случаем [[B-дерево#B.2B-.D0.B4.D0.B5.D1.80.D0.B5.D0.B2.D0.BE|B+ дерева]].
== Свойства ==
2-3 дерево {{---}} сбалансированное дерево поиска, обладающее следующими свойствами:
*нелистовые вершины имеют либо <tex>2</tex>, либо <tex>3</tex> сына,
*нелистовая вершина, имеющая двух сыновей, хранит максимум левого поддерева. Нелистовая вершина, имеющая трех сыновей, хранит два значения. Первое значение хранит максимум левого поддерева, второе максимум центрального поддерева,
*сыновья упорядочены по значению максимума поддерева сына,
*все листья лежат на одной глубине,
*Высота 2-3 дерева <tex>O(\log{n})</tex>, где <tex> n </tex> {{---}} количество элементов в дереве.

== Операции ==
Введем следующие обозначения:
*<tex>\mathtt{root}</tex> {{---}} корень 2-3 дерева.
Каждый узел дерева обладает полями:
*<tex>\mathtt{parent}</tex> {{---}} родитель узла,
*<tex>\mathtt{sons}</tex> {{---}} сыновья узла,
*<tex>\mathtt{keys}</tex> {{---}} ключи узла,
*<tex>\mathtt{length}</tex> {{---}} количество сыновей.
=== Поиск ===
*<tex>x</tex> {{---}} искомое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве.

Изначально <tex>t = \mathtt{root}</tex>. Будем просматривать ключи в узлах, пока узел не является листом. Рассмотрим два случая:
*у текущей вершины два сына. Если её значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

*у текущей вершины три сына. Если второе значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[2]}</tex>. Если первое значение меньше <tex>x</tex>, то <tex>t = \mathtt{t.sons[1]}</tex>, иначе <tex>t = \mathtt{t.sons[0]}</tex>.

'''Node''' search('''int''' x):
Node t = root
'''while''' (t не является листом)
'''if''' (t.length == 2)
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''else'''
'''if''' (t.keys[1] < x)
t = t.sons[2]
'''else'''
'''if''' (t.keys[0] < x)
t = t.sons[1]
'''else''' t = t.sons[0]
'''return''' t
Пример поиска в 2-3 дереве, так как элемент <tex>6</tex> существует, то был возвращен корректный узел, так как элемента <tex>10</tex> нет, возвращается некорректный узел. На основе этого можно сделать метод <tex>\mathtt{exist}</tex>, проверяющий наличии элемента в дереве.

[[Файл:23treesearch.png|border]]

=== Вставка элемента ===
*<tex>x</tex> {{---}} добавляемое значение,
*<tex>t</tex> {{---}} текущая вершина в дереве. Изначально <tex>t = \mathtt{root}</tex>.
Если корня не существует {{---}} дерево пустое, то новый элемент и будет корнем (одновременно и листом). Иначе поступим следующим образом:

Найдем сперва, где бы находился элемент, применив <tex>\mathtt{search(x)}</tex>. Далее проверим есть ли у этого узла родитель, если его нет, то в дереве всего один элемент {{---}} лист. Возьмем этот лист и новый узел, и создадим для них родителя, лист и новый узел расположим в порядке возрастания.

Если родитель существует, то подвесим к нему ещё одного сына. Если сыновей стало <tex>4</tex>, то разделим родителя на два узла, и повторим разделение теперь для его родителя (перед разделением обновим ключи).

splitParent('''Node''' t):
'''if''' (t.length > 3)
Node a;
a.sons[0] = t.sons[2]
a.sons[1] = t.sons[3]
t.sons[2].parent = a
t.sons[3].parent = a
a.keys[0] = t.keys[2]
a.length = 2
t.length = 2
t.sons[2] = '''null'''
t.sons[3] = '''null'''
'''if''' (t.parent != '''null''')
t.parent[t.length] = a
t.length++
сортируем сыновей у t.parent
splitParent(t.parent)
'''else''' //мы расщепили корень, надо подвесить его к общему родителю, который будет новым корнем
Node t = root
root.sons[0] = t
root.sons[1] = a
t.parent = root
a.parent = root
root.length = 2
сортируем сыновей у root
Если сыновей стало <tex>3</tex>, то ничего не делаем. Далее необходимо восстановить ключи на пути от новой вершины до корня:
updateKeys('''Node''' t):
Node a = t.parent
'''while''' (a != '''null''')
'''for''' i = 0 .. a.length - 1
a.keys[i] = max(a.sons[i]) //max {{---}} возвращает максимальное значение в поддереве.
a = a.parent //Примечание: max легко находить, если хранить максимум
//правого поддерева в каждом узле {{---}} это значение и будет max(a.sons[i])

<tex>\mathtt{updateKeys}</tex> необходимо запускать от нового узла.
Добавление элемента:
insert('''int''' x):
Node n = Node(x)
'''if''' (root == null)
root = n
return
Node a = search(x)
'''if''' (a.parent == '''null''')
Node t = root
root.sons[0] = t
root.sons[1] = n
t.parent = root
n.parent = root
root.length = 2
сортируем сыновей у root
'''else'''
Node p = a.parent
p.sons[p.length] = n
p.length++
n.parent = p
сортируем сыновей у p
updateKeys(n)
split(n)
updateKeys(n)
Так как мы спускаемся один раз, и поднимаемся вверх при расщеплении родителей не более одного раза, то <tex>\mathtt{insert}</tex> работает за <tex>O(\log{n})</tex>.

Примеры добавления:

[[Файл:23treeinsert.png|border|600px]]

[[Файл:23treeinsert2.png|800px|border]]

[[Файл:23treeinsert3.png|800px|border]]

=== Удаление элемента ===
*<tex>x</tex> {{---}} значение удаляемого узла,
*<tex>t</tex> {{---}} текущий узел.
Пусть изначально <tex>t = \mathtt{search(x)}</tex> {{---}} узел, где находится <tex>x</tex>.

Если у <tex>t</tex> не существует родителя, то это корень. Удалим его.

Если у <tex>t</tex> существует родитель, и у него <tex>3</tex> сына, то просто удалим <tex>t</tex>. Обновим ключи, запустив <tex>\mathtt{updateKeys}</tex> от любого брата <tex>t</tex>.

Если у родителя(<tex>\mathtt{t.parent}</tex>) <tex>2</tex> сына, то удалим <tex>t</tex>, а его брата(<tex>b</tex> перецепим к родителю соседнего листа(обозначим его за <tex>p</tex>). Вызовем <tex>\mathtt{updateKeys}(b)</tex> и <tex>\mathtt{splitParent}(p)</tex>, так как у <tex>p</tex> могло оказаться <tex>4</tex> сына. Удалим теперь и <tex>\mathtt{t.parent}</tex>. После возврата из рекурсии обновим все ключи с помощью <tex>\mathtt{updateKeys()}</tex>, запустившись от <tex>b</tex>.
[[Файл:23treedelete.png|thumb|center|удаление элемента с ключом 2|1150px]]

=== Следующий и предыдущий ===
*<tex>x</tex> {{---}} поисковый параметр,
*<tex>t</tex> {{---}} текущий узел.
В силу того, что наши узлы отсортированы по максимуму в поддереве, то следующий объект это соседний лист справа. Попасть туда можно следующим образом:
будем подниматься вверх, пока у нас не появится первой возможности свернуть направо вниз. Как только мы свернули направо вниз, будем идти всегда влево. Таким образом, мы окажемся в соседнем листе. Если мы не смогли ни разу свернуть направо вниз, и пришли в корень, то следующего объекта не существует. Случай с предыдущим симметричен.
Node next('''int x''')
Node t = search(x)
'''if''' (t.keys[0] > x) //x не было в дереве, и мы нашли следующий сразу
'''return''' t
'''while''' (t != '''null''')
t = t.parent
if (можно свернуть направо вниз)
в t помещаем вершину, в которую свернули
'''while''' (пока t {{---}} не лист)
t = t.sons[0]
'''return''' t
'''return''' t;

[[Файл:23treenext.png|thumb|center|400px|путь при поиске следующего элемента после 2]]

=== Нахождение m следующих элементов ===
B+ деревья, поддерживают операцию <tex>\mathtt{find}</tex>, которая позволяет находить m следующих элементов. Наивная реализация выглядит следующим образом, будем вызывать <tex>m</tex> раз поиск следующего элемента, такое решение работает за <tex>O(m * \log{n})</tex>. Но 2-3 деревья, позволяют находить m следующих элементов за <tex>O(m + \log{n})</tex>, что значительно ускоряет поиск при больших <tex>m</tex>.
По построению, все листья у нас отсортированы в порядке возрастания, воспользуемся этим для нахождения m элементов. Нам необходимо связать листья, для этого модифицируем
<tex>\mathtt{insert}</tex> и <tex>\mathtt{delete}</tex>. Добавим к узлам следующие поля:
*<tex>\mathtt{right}</tex> {{---}} указывает на правый лист,
*<tex>\mathtt{left}</tex> {{---}} указывает на левый лист.
Пусть <tex>t</tex> - добавленный узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом конце, после того как мы уже обновили все ключи, найдем <tex>\mathtt{next(t)}</tex> и запишем ссылку на него в <tex>\mathtt{t.right}</tex>. Аналогично с левым.
Пусть <tex>t</tex> - удаляемый узел.
Изменим <tex>\mathtt{insert}</tex> следующим образом: в самом начале, до удаления <tex>t</tex>, найдем следующий (<tex>mathtt{next}</tex>) и запишем в (<tex>mathtt{next.left}</tex>) правый лист относительно <tex>t</tex>. С левым поступим аналогично.

В итоге, мы имеем двусвязный список в листьях, и чтобы нам вывести <tex>m</tex> элементов, нам достаточно один раз найти нужный элемент и пробежаться вправо на <tex>m</tex> элементов.

[[Файл:23treefind.png|border]]

== См. также ==
* [[B-дерево]]
* [[Splay-дерево]]
* [[АВЛ-дерево]]
* [[Декартово дерево]]
* [[Красно-черное дерево]]

== Источники информации ==
* [http://is.ifmo.ru/vis/tree23/tree23_ru.html is.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://rain.ifmo.ru/cat/view.php/vis/trees/2-3-2002 rain.ifmo.ru {{---}} Визуализатор 2-3 дерева]
* [http://ru.wikipedia.org/wiki/2-3-дерево Википедия {{---}} 2-3 дерево]
* Д. Кнут «Искусство программирования. Сортировка и поиск», часть 6.2.4

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Структуры данных]]
[[Категория:Деревья поиска]]