List order maintenance — различия между версиями
(Structure dramaticly improved) |
(Structure) |
||
Строка 1: | Строка 1: | ||
[[Файл:ListABCD.jpg|250px|thumb|right|Для такого списка команда <tex>\mathrm{order(D,B)}</tex> выдаст <tex>\mathrm{false}</tex>.]] | [[Файл:ListABCD.jpg|250px|thumb|right|Для такого списка команда <tex>\mathrm{order(D,B)}</tex> выдаст <tex>\mathrm{false}</tex>.]] | ||
− | '''List order maintance''' ( | + | '''List order maintance''' (рус. <i>поддержка порядка в списке</i>) {{---}} проблема поддержки списка со следующими операциями: |
* <tex>\mathrm{insert(p, q)}</tex> {{---}} вставка нового элемента <tex>p</tex> в список сразу после <tex>q</tex>; | * <tex>\mathrm{insert(p, q)}</tex> {{---}} вставка нового элемента <tex>p</tex> в список сразу после <tex>q</tex>; | ||
* <tex>\mathrm{remove(p)}</tex> {{---}} удаление элемента <tex>p</tex> из списка; | * <tex>\mathrm{remove(p)}</tex> {{---}} удаление элемента <tex>p</tex> из списка; | ||
Строка 6: | Строка 6: | ||
Существует реализация структуры, где все операции выполняются за амортизационную <tex>O(1)</tex>. | Существует реализация структуры, где все операции выполняются за амортизационную <tex>O(1)</tex>. | ||
− | + | Потребность в списке с командой порядка возникает, к примеру, в реализации [[Персистентные структуры данных|персистентного дерева поиска]]. | |
− | == Алгоритм | + | == Алгоритм == |
+ | === Идея === | ||
[[Файл:ListABCDwithMarks.jpg|250px|thumb|right|Пример расставления меток для списка, <tex>u=3</tex>.]] | [[Файл:ListABCDwithMarks.jpg|250px|thumb|right|Пример расставления меток для списка, <tex>u=3</tex>.]] | ||
− | + | Все операции кроме <tex>\mathrm{order(p,q)}</tex> за <tex>O(1)</tex> может выполнить обычный [[Список|двусвязный список]]. Проблема возникает в тот момент, когда мы хотим получить порядок элементов, так как связный список не хранит информацию о нём. Пусть каждому узлу сопоставлено некоторое число, при этом все числа строго возрастают от начала списка к его концу. Таким образом, эти числа, которые в дальнейшим будут называться метками, задают порядок на элементах списка. И, зная ссылки на два элемента <tex>p</tex> и <tex>q</tex>, можно за <tex>O(1)</tex> ответить на запрос <tex>\mathrm{order(p,q)}</tex>, просто сравнив их метки. Заметим, что добавление меток никак не влияет на реализацию операции <tex>\mathrm{remove(p)}</tex>. Однако с реализацией <tex>\mathrm{insert(p,q)}</tex> возникают проблемы: при добавлении нового элемента <tex>q</tex> после узла <tex>p</tex>, узлу <tex>q</tex> надо присвоить метку, которая строго больше предыдущего элемента и строго меньше следующего. Исходя из предположения, что метки имеют конечную длину, в какой-то момент возникнет ситуация, что новой метки не найдётся. Тогда будем выдавать элементам списка новые метки. Теперь рассмотрим алгоритм, который позволяет реализовать эту идею. | |
− | |||
− | + | === Алгоритм за O(logn) === | |
− | + | Метки будем хранить в виде чисел в двоичной системе счисления. Посмотрим, какой длины должны быть метки, чтобы перераспределения не случались слишком часто. Если <tex>u</tex> {{---}} длина каждой метки, то для начала пусть <tex>u:\dfrac{n}{2}<2^u \leqslant 2n</tex>, где <tex>n</tex> {{---}} количество элементов в списке. Если после добавления или удаления элементов <tex>u</tex> перестанет удовлетворять неравенству, пересчитаем все метки заново. Пересчет меток занимает амортизационно <tex>O(1)</tex> по аналогии с саморасширяющимся массивом. Позже, в доказательстве времени работы, мы несколько уточним значение <tex>u</tex>. | |
− | |||
− | |||
− | |||
− | <b>Способ хранения меток.</b> | + | |
− | * <b>в листьях</b> будем хранить, используется ли уже эта метка. Пусть <tex>\mathrm{weight(x)}</tex> {{---}} это количество помеченных (используемых) листьев (меток) в поддереве <tex>x</tex>, а <tex>\mathrm{size(x)}</tex> {{---}} это количество всех листьев в поддереве <tex>x</tex>; | + | <b>Способ хранения меток.</b> Будем хранить все метки в [[Сверхбыстрый цифровой бор | цифровом боре]] высоты <tex>u</tex> (там хранятся не только используемые метки, а вообще все возможные заданной длины). В узлах будем хранить: |
+ | * <b>в листьях</b> будем хранить, используется ли уже эта метка. Пусть <tex>\mathrm{weight(x)}</tex> {{---}} это количество помеченных (используемых) листьев (меток) в поддереве <tex>x</tex>, а <tex>\mathrm{size(x)}</tex> {{---}} это количество всех листьев в поддереве <tex>x</tex>;[[Файл:UBitTreeExample.jpg|350px|thumb|right|Пример цифрового бора для меток, где узел с крестиком {{---}} переполненный узел, а с галочкой {{---}} непереполненный для <tex>\alpha=1,5</tex>.]] | ||
* <b>в нелистовых узлах</b> будем хранить, является ли узел переполненным. Для любой <tex>1<\alpha<2</tex> будем считать, что узел дерева переполнен, если <tex>\dfrac{\mathrm{weight(x)}}{\mathrm{size(x)}}>\dfrac{1}{\alpha^{\mathrm{height(x)}}}</tex>. Стоит заметить, что все листья всегда непереполнены. В худшем случае: <tex> \dfrac{\mathrm{weight(leave)}}{\mathrm{size(leave)}} = 1 = \dfrac{1}{\alpha^{\mathrm{height(x)}}} = \dfrac{1}{\alpha^{0}}</tex>. Получается, что, чем выше, тем более разреженными должны быть поддеревья непереполненных узлов. | * <b>в нелистовых узлах</b> будем хранить, является ли узел переполненным. Для любой <tex>1<\alpha<2</tex> будем считать, что узел дерева переполнен, если <tex>\dfrac{\mathrm{weight(x)}}{\mathrm{size(x)}}>\dfrac{1}{\alpha^{\mathrm{height(x)}}}</tex>. Стоит заметить, что все листья всегда непереполнены. В худшем случае: <tex> \dfrac{\mathrm{weight(leave)}}{\mathrm{size(leave)}} = 1 = \dfrac{1}{\alpha^{\mathrm{height(x)}}} = \dfrac{1}{\alpha^{0}}</tex>. Получается, что, чем выше, тем более разреженными должны быть поддеревья непереполненных узлов. | ||
− | + | ||
<b>Перераспределение меток.</b> Тогда, как только мы получаем команду вставить элемент, которому не хватает метки, мы поднимаемся вверх от метки элемента <tex>p</tex>, пока не найдем первый непереполненный узел. Может случиться такое, что на всем пути до корня мы не найдем ни одного непереполненного узла. Чтобы этого избежать, изменим требования к <tex>u</tex> позже. Как только мы нашли первый непереполненный узел, переназначим метки в его поддереве так, чтобы они находились друг от друга на одинаковых расстояниях (места точно хватит, так как <tex>\dfrac{\mathrm{weight(x)}}{\mathrm{size(x)}}\leqslant\dfrac{1}{\alpha^{\mathrm{height(x)}}}</tex>, если узел непереполненный). После этого плотность распределения всех занятых листьев составит примерно <tex>\dfrac{1}{\alpha^{\mathrm{height(x)}}}</tex>. | <b>Перераспределение меток.</b> Тогда, как только мы получаем команду вставить элемент, которому не хватает метки, мы поднимаемся вверх от метки элемента <tex>p</tex>, пока не найдем первый непереполненный узел. Может случиться такое, что на всем пути до корня мы не найдем ни одного непереполненного узла. Чтобы этого избежать, изменим требования к <tex>u</tex> позже. Как только мы нашли первый непереполненный узел, переназначим метки в его поддереве так, чтобы они находились друг от друга на одинаковых расстояниях (места точно хватит, так как <tex>\dfrac{\mathrm{weight(x)}}{\mathrm{size(x)}}\leqslant\dfrac{1}{\alpha^{\mathrm{height(x)}}}</tex>, если узел непереполненный). После этого плотность распределения всех занятых листьев составит примерно <tex>\dfrac{1}{\alpha^{\mathrm{height(x)}}}</tex>. | ||
+ | |||
<b>Докажем амортизационную стоимость операции добавления.</b> | <b>Докажем амортизационную стоимость операции добавления.</b> | ||
Строка 34: | Строка 33: | ||
Теперь выберем такое <tex>u</tex>, чтобы корень никогда не переполнялся: <tex>\dfrac{\mathrm{weight(root)}}{\mathrm{size(root)}} < \dfrac{1}{\alpha^{\mathrm{height(root)}}} \Rightarrow \dfrac{n}{2^u} < \dfrac{1}{\alpha ^u} \Rightarrow u \geqslant \log_{\frac{ 2}{\alpha}} n</tex>. Тогда операция добавления работает за <tex>O(\log n)</tex>. | Теперь выберем такое <tex>u</tex>, чтобы корень никогда не переполнялся: <tex>\dfrac{\mathrm{weight(root)}}{\mathrm{size(root)}} < \dfrac{1}{\alpha^{\mathrm{height(root)}}} \Rightarrow \dfrac{n}{2^u} < \dfrac{1}{\alpha ^u} \Rightarrow u \geqslant \log_{\frac{ 2}{\alpha}} n</tex>. Тогда операция добавления работает за <tex>O(\log n)</tex>. | ||
− | == Алгоритм за O(1) == | + | === Алгоритм за O(1) === |
[[Файл:GlobalandLocalLabelstoConst.jpg|350px|thumb|right|y-fast-tree для меток.]] | [[Файл:GlobalandLocalLabelstoConst.jpg|350px|thumb|right|y-fast-tree для меток.]] | ||
Предыдущий алгоритм работает за логарифм из-за того, что слишком часто приходится делать перераспределение меток. Используем <tex>\mathrm{y}{-}\mathrm{fast}{-}\mathrm{trie}</tex> (модифицированный цифровой бор), чтобы улучшить время работы операции добавления до <tex>O(1)</tex>. | Предыдущий алгоритм работает за логарифм из-за того, что слишком часто приходится делать перераспределение меток. Используем <tex>\mathrm{y}{-}\mathrm{fast}{-}\mathrm{trie}</tex> (модифицированный цифровой бор), чтобы улучшить время работы операции добавления до <tex>O(1)</tex>. |
Версия 23:56, 10 апреля 2016
List order maintance (рус. поддержка порядка в списке) — проблема поддержки списка со следующими операциями:
- — вставка нового элемента в список сразу после ;
- — удаление элемента из списка;
- — команда, возвращающая , если в списке находится до и иначе.
Существует реализация структуры, где все операции выполняются за амортизационную персистентного дерева поиска.
. Потребность в списке с командой порядка возникает, к примеру, в реализацииСодержание
Алгоритм
Идея
Все операции кроме двусвязный список. Проблема возникает в тот момент, когда мы хотим получить порядок элементов, так как связный список не хранит информацию о нём. Пусть каждому узлу сопоставлено некоторое число, при этом все числа строго возрастают от начала списка к его концу. Таким образом, эти числа, которые в дальнейшим будут называться метками, задают порядок на элементах списка. И, зная ссылки на два элемента и , можно за ответить на запрос , просто сравнив их метки. Заметим, что добавление меток никак не влияет на реализацию операции . Однако с реализацией возникают проблемы: при добавлении нового элемента после узла , узлу надо присвоить метку, которая строго больше предыдущего элемента и строго меньше следующего. Исходя из предположения, что метки имеют конечную длину, в какой-то момент возникнет ситуация, что новой метки не найдётся. Тогда будем выдавать элементам списка новые метки. Теперь рассмотрим алгоритм, который позволяет реализовать эту идею.
за может выполнить обычныйАлгоритм за O(logn)
Метки будем хранить в виде чисел в двоичной системе счисления. Посмотрим, какой длины должны быть метки, чтобы перераспределения не случались слишком часто. Если
— длина каждой метки, то для начала пусть , где — количество элементов в списке. Если после добавления или удаления элементов перестанет удовлетворять неравенству, пересчитаем все метки заново. Пересчет меток занимает амортизационно по аналогии с саморасширяющимся массивом. Позже, в доказательстве времени работы, мы несколько уточним значение .
Способ хранения меток. Будем хранить все метки в цифровом боре высоты (там хранятся не только используемые метки, а вообще все возможные заданной длины). В узлах будем хранить:
- в листьях будем хранить, используется ли уже эта метка. Пусть — это количество помеченных (используемых) листьев (меток) в поддереве , а — это количество всех листьев в поддереве ;
- в нелистовых узлах будем хранить, является ли узел переполненным. Для любой будем считать, что узел дерева переполнен, если . Стоит заметить, что все листья всегда непереполнены. В худшем случае: . Получается, что, чем выше, тем более разреженными должны быть поддеревья непереполненных узлов.
Перераспределение меток. Тогда, как только мы получаем команду вставить элемент, которому не хватает метки, мы поднимаемся вверх от метки элемента , пока не найдем первый непереполненный узел. Может случиться такое, что на всем пути до корня мы не найдем ни одного непереполненного узла. Чтобы этого избежать, изменим требования к позже. Как только мы нашли первый непереполненный узел, переназначим метки в его поддереве так, чтобы они находились друг от друга на одинаковых расстояниях (места точно хватит, так как , если узел непереполненный). После этого плотность распределения всех занятых листьев составит примерно .
Докажем амортизационную стоимость операции добавления.
- С одной стороны, повторное перераспределение меток в поддереве узла потребуется, когда сын этого узла снова переполнится. Если — сын , то он переполнится, когда . Чтобы это произошло, требуется, чтобы было сделано еще добавлений.
- С другой стороны, следующее переспределение меток произойдет, когда . Получается, что за операций перераспределения меток требуется сделать операций добавления.
Тогда если за каждую операцию добавления брать
монет, то за добавления накопится столько монет, чтобы расплатиться за следующую операцию перераспределения в узле . Проблема в том, что таким образом надо платить за каждый уровень, а количество уровней (бит) равно . Тогда амортизированная стоимость добавления .Теперь выберем такое
, чтобы корень никогда не переполнялся: . Тогда операция добавления работает за .Алгоритм за O(1)
Предыдущий алгоритм работает за логарифм из-за того, что слишком часто приходится делать перераспределение меток. Используем
(модифицированный цифровой бор), чтобы улучшить время работы операции добавления до .У каждого элемента списка будет две метки: глобальная и локальная. Глобальная задает блок, локальная — положение элемента внутри блока. Описание взаимодействия с метками:
- локальные метки внутри каждого блока будем присваивать каждому элементу от до жадно. Стоит заметить, что внутри блока никогда не будет проблемы, что кому-то не хватит метки или придется сделать перераспределение меток, так как, если мы каждый раз в качестве метки будем брать среднее значение, то для того, чтобы был конфликт из-за меток, нужно больше, чем ключей (противоречит условию);
- глобальные метки будут организованы в структуру, использовавшуюся в реализации операции за логарифмическое время. Глобальные метки для блоков нам придется менять, когда один из блоков переполнился. Тогда разделим блок на два, присвоив метку второму, методом, описанным выше (поднимемся до первого непереполненного). Каждый блок будет иметь занятых меток. Аналогично, когда в каком-то блок становится слишком мало ключей, мы его сливаем с соседним.
Внутри блоков мы присваиваем ключи за
, а, аналогичный приведенному выше анализ показывает, что, чтобы потребовалось перераспределение глобальных меток, требуется изменений локальных меток. За эти изменения накопим монет для изменения глобальных меток, тогда операция добавления работает за константное время.Использование памяти
Из-за того, что
зависит от выбранной , сильно влияет на реализацию. Увеличивая , мы уменьшаем стоимость операции добавления (количество монет, которые надо брать: ), но увеличиваем , значит, требуется больше памяти, а, уменьшая , мы выигрываем в памяти, но проигрываем во времени операции добавления. Так как для реализации структуры мы используем , требуется памяти.Послесловие
Впервые реализацию такой структуры данных со всеми операциями за константное время амортизационно предложили[1] Dietz и Sleator, однако их доказательство времени работы было намного сложнее вышеизложенного анализа. Поэтому позже группа ученых во главе с Michael A. Bender разработала[2] более простое доказательство, изложенное выше, впервые описанное в их статье Two simlified algorithms for maintaining order in a list. Послесловие их статьи таково:
Dietz and Sleator is quite influential With its tags and its proofs by potential But to teach it in class Is a pain in the ass So our new result is preferential.