Троичное дерево по сравнению с хеш-таблицей

Question

Троичное дерево по сравнению с хеш-таблицей

Если у вас есть PowerShell Core (v6.1 или выше), вы можете объединить -replace с заменой на основе блока сценариев :

PS> '192.168.13.1' -replace '(?<=^(\d+\.){2})\d+', { 1 +  Если у вас есть  PowerShell  Core   (v6.1 или выше), вы можете  объединить -replace с заменой на основе блока сценариев   : 
 [110]   Отрицательное обратное утверждение (?<=^(\d+\.){2}) сопоставляет все до 3-го октета, но не включает его, не считая его частью общего соответствия для замены. , 
  (?<=...) является проверочным утверждением, \d+ соответствует одной или нескольким (+) цифрам (\d), \. и  литералу  [ 118], а {2} соответствует предыдущему подвыражению ((...)) 2 раза. 
 
   \d+ затем соответствует только 3-му октету; поскольку больше ничего не найдено, оставшаяся часть строки (. и 4-й октет) остается на месте. 
 
   Внутри блока замещающего сценария ({ ... }) 
 Если у вас есть  PowerShell  Core   (v6.1 или выше), вы можете  объединить [111] с заменой на основе блока сценариев   : 
 [110]   Отрицательное обратное утверждение [112] сопоставляет все до 3-го октета, но не включает его, не считая его частью общего соответствия для замены. , 
  [113] является проверочным утверждением, [114] соответствует одной или нескольким ([115]) цифрам ([116]), [117] и  литералу  [ 118], а [119] соответствует предыдущему подвыражению ([1110]) 2 раза. 
 
   [1111] затем соответствует только 3-му октету; поскольку больше ничего не найдено, оставшаяся часть строки ([1112] и 4-й октет) остается на месте. 
 
   Внутри блока замещающего сценария ([1113]) [1114] ссылается на результаты сопоставления в виде экземпляра  [MatchInfo] ; его .Value - это совпадающая строка, то есть 3-й октет, к которому можно добавить 1. 
  Примечание к типу данных: при использовании 1, неявного [int], в качестве  LHS , RHS (строка .Value  ) неявно приводится в действие на [int] (вы можете использовать явное приведение). 
  На выходе все, что возвращает блок скрипта, автоматически приводится к строке  . 
 
 
 Если вы должны поддерживать совместимость с  Windows PowerShell , рассмотрите  полезный ответ Джеффа Цейтлина .  ссылается на результаты сопоставления в виде экземпляра  [MatchInfo] ; его .Value - это совпадающая строка, то есть 3-й октет, к которому можно добавить 1. 
  Примечание к типу данных: при использовании 1, неявного [int], в качестве  LHS , RHS (строка .Value  ) неявно приводится в действие на [int] (вы можете использовать явное приведение). 
  На выходе все, что возвращает блок скрипта, автоматически приводится к строке  . 
 
 
 Если вы должны поддерживать совместимость с  Windows PowerShell , рассмотрите  полезный ответ Джеффа Цейтлина . .Value }
192.168.14.1

Если вы должны поддерживать совместимость с Windows PowerShell , рассмотрите полезный ответ Джеффа Цейтлина .

13

algorithm hashtable ternary-search-tree

задан Community 23 May 2017 в 12:34

4 ответа

Другие вопросы по тегам:

algorithm hashtable ternary-search-tree

Похожие вопросы:

score 7 · Answer 1

Вот что я собираю у доктора. Статья Доббса доступна из ссылки Принстона, которую вы дали:

Троичные деревья поиска работают на 10% быстрее, чем хеш-таблицы в некоторых задачах поиска. Иногда они медленнее - в значительной степени зависят от используемой машины.
TRT - это пользовательская структура данных, настроенная двумя из лучших умов информатики - Джон Бентли и Роберт Седжвик оба написали хорошие учебники и сделали свою долю практического программирования. Хеш-таблицы считаются заурядными.
Используемые константы значительны, как говорит Хао Вуй Лин.
В целом, это зависит от решаемой вами проблемы. Более быстрое время разработки и почти повсеместная поддержка хеш-таблиц во многих языках программирования часто важнее, чем десятипроцентное улучшение времени выполнения.

score 4 · Answer 2

Единственный способ ответить на этот вопрос - эмпирически. Ответ зависит от деталей вашей реализации, от того, какие виды поиска вы выполняете, какое у вас оборудование и какой компилятор вы используете. Вы можете скопировать код C из Принстона. Если вы хотите попробовать функциональный язык, в Standard ML есть хэш-таблицы (см. SML / NJ ), а вот несколько ML для троичных деревьев поиска:

type key = Key.ord_key
type item = Key.ord_key list

datatype set = NODE of { key : key, lt : set, eq : set, gt : set }
             | LEAF

val empty = LEAF

fun member (_, LEAF) = false
  | member (h::t, NODE {key, lt, eq, gt}) =
      (case Key.compare (h, key)
         of EQUAL   => member(t, eq)
          | LESS    => member(h::t, lt)
          | GREATER => member(h::t, gt))
  | member ([], NODE {key, lt, eq, gt}) =
      (case Key.compare (Key.sentinel, key)
         of EQUAL   => true
          | LESS    => member([], lt)
          | GREATER => member([], gt))

exception AlreadyPresent

fun insert(h::t, LEAF) =
      NODE { key = h, eq = insert(t, LEAF), lt = LEAF, gt = LEAF }
  | insert([], LEAF) =
      NODE { key = Key.sentinel, eq = LEAF, lt = LEAF, gt = LEAF }
  | insert(h::t, NODE {key, lt, eq, gt}) =
      (case Key.compare (h, key)
         of EQUAL   => NODE {key = key, lt = lt, gt = gt, eq = insert(t, eq)}
          | LESS    => NODE {key = key, lt = insert(h::t, lt), gt = gt, eq = eq}
          | GREATER => NODE {key = key, lt = lt, gt = insert(h::t, gt), eq = eq})
  | insert([], NODE {key, lt, eq, gt}) =
      (case Key.compare (Key.sentinel, key)
         of EQUAL   => raise AlreadyPresent
          | LESS    => NODE {key = key, lt = insert([], lt), gt = gt, eq = eq}
          | GREATER => NODE {key = key, lt = lt, gt = insert([], gt), eq = eq})

fun add(l, n) = insert(l, n) handle AlreadyPresent => n

score 1 · Answer 3

log (n) медленно растет, поэтому часто требуется огромный объем данных, прежде чем он будет работать медленнее, чем алгоритм O (1), принимая во внимание постоянный коэффициент.

score 0 · Answer 4

Меня это тоже очень интригует. Но из вики, которую я читал, утверждалось, что троичное дерево быстрее в большинстве задач поиска. Это неудивительно, потому что, хотя хеш-таблица имеет поиск O (1), вам все равно нужно время для хеширования. Так что на самом деле это не O (1), а скорее как O (k), где k не зависит от N (количество элементов в структуре данных). Это может создать впечатление, что Hash Table работает быстрее. Однако, если вы имеете дело с большими структурами, k быстро складывается, и наступает момент, когда скорость поиска в Hash Tables становится медленнее, чем в Ternary Tree.