Hashed Array Tree — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Расход памяти)
м (Поправка орфографии.)
 
(не показаны 3 промежуточные версии этого же участника)
Строка 19: Строка 19:
 
     '''return''' top[topIndex(j)][leafIndex(j)]
 
     '''return''' top[topIndex(j)][leafIndex(j)]
 
*
 
*
Рассмотрим как происходит вычисление адреса на примере. Пусть у нас есть HAT с размером листа равным <tex>4</tex>, тогда для нашего случая <tex>power = 2</tex>. Получим значения функций для элемент под номером <tex>5</tex>:  
+
Рассмотрим как происходит вычисление адреса на примере. Пусть у нас есть HAT с размером листа равным <tex>4</tex>, тогда для нашего случая <tex>power = 2</tex>. Получим значения функций для элемента под номером <tex>5</tex>:  
 
*<tex>topIndex(5)</tex> : в данном случае битовый сдвиг эквивалентен операции деления (взятию по модулю) <tex>j</tex> на <tex>2^{2}</tex>. То есть получим <tex>1</tex> {{---}} действительно элемент под номером <tex>5</tex> находится в первом листе (нумерация листов с <tex>0</tex>).
 
*<tex>topIndex(5)</tex> : в данном случае битовый сдвиг эквивалентен операции деления (взятию по модулю) <tex>j</tex> на <tex>2^{2}</tex>. То есть получим <tex>1</tex> {{---}} действительно элемент под номером <tex>5</tex> находится в первом листе (нумерация листов с <tex>0</tex>).
*<tex>leafIndex(5)</tex> : в данном случае битовый сдвиг эквивалентен умножению <tex>1</tex> на <tex>2^{2}</tex>. То есть после вычитания <tex>1</tex> получим число формата <tex>011..11</tex>, в нашем случае {{---}} <tex>011</tex>. Формула для <tex>leafIndex</tex> справедлива, так как элементы, которые находятся в разных листьях и различаются на <tex>2^k</tex>, будут иметь одинаковую позицию в этих листах, а младшие <tex>k</tex> бит у них будут общими. Поэтому сделаем операцию побивое "и" к запрашиваему индексу и к <tex> 2^k - 1 </tex> и получим нужный индекс в массиве <tex> leaf </tex>.
+
*<tex>leafIndex(5)</tex> : в данном случае битовый сдвиг эквивалентен умножению <tex>1</tex> на <tex>2^{2}</tex>. То есть после вычитания <tex>1</tex> получим число формата <tex>011..11</tex>, в нашем случае {{---}} <tex>011</tex>. Формула для <tex>leafIndex</tex> справедлива, так как элементы, которые находятся в разных листьях и различаются на <tex>2^k</tex>, будут иметь одинаковую позицию в этих листах, а младшие <tex>k</tex> бит у них будут общими. Поэтому сделаем операцию побитовое "и" к запрашиваемому индексу и к <tex> 2^k - 1 </tex> и получим нужный индекс в массиве <tex> leaf </tex>.
 
<tex>5_{10} = 101_2</tex> , следовательно <tex>101</tex> <tex>\&</tex> <tex>011 = 001</tex>, то есть индекс в листе равен <tex>1</tex> (в листах нумерация тоже с <tex>0</tex>).
 
<tex>5_{10} = 101_2</tex> , следовательно <tex>101</tex> <tex>\&</tex> <tex>011 = 001</tex>, то есть индекс в листе равен <tex>1</tex> (в листах нумерация тоже с <tex>0</tex>).
  

Текущая версия на 17:41, 10 июля 2019

HAT (Hashed Array Tree) — структура данных, объединяющая в себе некоторые возможности массивов, хэш-таблиц и деревьев. Внешне структура похожа на хеш-таблицу с разрешением коллизий методом цепочек, отсюда и название. В действительности HAT — это эффективный способ реализовать массивы переменной длины, так как он предлагает хорошую производительность порядка [math]O(N)[/math], чтобы добавить [math]N[/math] элементов к пустому массиву, и требует всего лишь [math]O(\sqrt{N})[/math] дополнительной памяти.

Значимость[править]

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

Описание структуры[править]

HAT состоит из главного массива указателей [math]top[/math] и ряда листьев [math]leaf[/math] (так же одномерные массивы), в которых хранятся элементы. Возможное число указателей в главном массиве и возможное число элементов в каждом листе равны между собой и являются степенями двойки. HAT заполняется элементами от самого малого листа к самому большому, при этом каждый лист заполняется слева направо.

Получение элемента по номеру[править]

Благодаря использованию степеней двойки, мы можем эффективно находить элементы в HAT, используя поразрядные операции. Пусть размер главного массива и каждого листа будет равен [math]2^{power}[/math].

 int topIndex(int j):
   // Получить номер указателя в основном массиве
   return j >> power
 int leafIndex(int j):
   // Получить номер листа
   return j & ((1 << power) - 1)
 T getHat(int j):
   // Вернуть элемент HAT. Нет проверки на выход за пределы массива.
   return top[topIndex(j)][leafIndex(j)]

Рассмотрим как происходит вычисление адреса на примере. Пусть у нас есть HAT с размером листа равным [math]4[/math], тогда для нашего случая [math]power = 2[/math]. Получим значения функций для элемента под номером [math]5[/math]:

  • [math]topIndex(5)[/math] : в данном случае битовый сдвиг эквивалентен операции деления (взятию по модулю) [math]j[/math] на [math]2^{2}[/math]. То есть получим [math]1[/math] — действительно элемент под номером [math]5[/math] находится в первом листе (нумерация листов с [math]0[/math]).
  • [math]leafIndex(5)[/math] : в данном случае битовый сдвиг эквивалентен умножению [math]1[/math] на [math]2^{2}[/math]. То есть после вычитания [math]1[/math] получим число формата [math]011..11[/math], в нашем случае — [math]011[/math]. Формула для [math]leafIndex[/math] справедлива, так как элементы, которые находятся в разных листьях и различаются на [math]2^k[/math], будут иметь одинаковую позицию в этих листах, а младшие [math]k[/math] бит у них будут общими. Поэтому сделаем операцию побитовое "и" к запрашиваемому индексу и к [math] 2^k - 1 [/math] и получим нужный индекс в массиве [math] leaf [/math].

[math]5_{10} = 101_2[/math] , следовательно [math]101[/math] [math]\&[/math] [math]011 = 001[/math], то есть индекс в листе равен [math]1[/math] (в листах нумерация тоже с [math]0[/math]).

FullHAT.png

Добавление элементов[править]

  • Чаще всего при добавлении элемента в одном из листьев (последнем незаполненном на данный момент) найдется свободное место, что позволит осуществить быструю вставку — [math]O(1)[/math].
  • Реже мы столкнемся со случаем, когда необходимо создать новый лист. Достаточно всего лишь добавить указатель в свободную ячейку главного массива, что также позволит произвести вставку элемента за [math]O(1)[/math].
  • Самый интересный случай — когда главный массив и все листья заполнены. Cначала вычислим нужный размер (массивы [math]top[/math] и [math]leaf[/math] увеличиваются в [math]2[/math] раза, то есть [math]power = power \cdot 2 [/math]), затем скопируем элементы в новую структуру HAT, освобождая старые листья и распределяя новые листья(размер листа изменился, а значит количество элементов в листе и количество используемых листьев так же изменится).

Такой подход к расширению помогает избежать избыточного перекопирования, используемого во многих реализациях массивов переменной длины, потому что увеличения размеров всех массивов происходит редко (как будет видно ниже). Копировать элементы мы будем только тогда, когда главный массив полон (достигли соответствующей степени двойки, то есть [math] N = (2 \cdot 2)^k[/math], где [math]k[/math] — натуральное число), тогда общая сумма перекопирования будет равна [math]1+4+16+64+256+...+N[/math]. Воспользуемся тождеством: [math](x^{n+1} -1)=(x-1)(1+x+x^2+x^3+... + x^k)[/math], тогда для нашего случая: [math]1 +4+4^2+4^3+...+4^k = (4^{k+1} -1)/(4-1) = (4N-1)/3[/math], или около [math]4N/3[/math]. Это означает, что среднее число дополнительных операций копирования — [math]O(N)[/math] для последовательного добавления [math] N [/math] элементов, а не [math]O(N^2)[/math]. Мы получили [math]4N/3[/math] против [math]2N[/math] в обычном динамическом массиве, то есть константа уменьшилась.

AlgoF2.gif

Расход памяти[править]

HAT использует меньше дополнительной памяти, чем в стандартных подходах к расширению массивов, то есть полном перекопировании и перераспределении всего массива. Затраты дополнительной памяти (уже выделенной, но еще не используемой) в самом плохом случае — [math](top+leaf-1) ~= 2\sqrt{N} = O(\sqrt{N})[/math] (этот случай при пустой HAT — в [math]top[/math] один указатель на единственный пустой лист).

Если в листе будет [math]power/2[/math] элементов, то ожидаемая трата дополнительной памяти уменьшается до [math](top + leaf/2) \approx 1.5\sqrt{N}[/math]. Таким образом HAT использует [math]\Theta(\sqrt{N})[/math] дополнительной памяти. Это лучше динамического массива, который использует [math]O(N)[/math] дополнительной памяти сразу после перекопирования элементов, и лучше списка.

Эффективность[править]

Благодаря тому, что копирования в HAT происходят реже, чем в других реализациях динамических массивов, и в худшем случае требуется [math]O(\sqrt{N})[/math] памяти, ее можно использовать в любых программах, требующих работу с массивами переменной длинны, где использование других структур данных (например списков) не удобно. На многих алгоритмах HAT работает значительно быстрее стандартных массивов, дополнительно можно ознакомиться с результатами некоторых тестов[1].

Примечания[править]

Источники информации[править]

  • Wikipedia — Hashed array tree
  • Cline, M.P. and G.A. Lomow, C++ FAQs, Reading, MA: Addison-Wesley, 1995.
  • Cormen, T.H., C.E. Leiserson, and R.L. Rivest. Introduction to Algorithms, Cambridge, MA: MIT Press, 1990.