Речници

• Основната употреба на речника е да съхранява обекти, така, че те да могат да се намират бързо с използване на ключове.
• Подобно на приоритетната опашка, речникът е контейнер на двойки ключ-елемент.
• Независимо от това, че за приоритетната опашка се иска пълна наредба на ключовете, за речника тя е по опция.
• Най-простата форма на речника изисква само да може да се определи дали два ключа са еднакви.
  
• Когато е дефинирана пълна наредба на ключовете, имаме нареден речник, за който дефинираме допълнителни функции, които се отнасят до наредбата на ключовете.

• Речник АТД съхранява двойки ключ-елемент (k,e), които ще наричаме членове на речника (items), където k е ключ и e е елемент.
• В ненареден речник можем да използваме обект-тестер за проверка дали два ключа k₁ и k₂ са равни с функция за равенство (еднаквост) isEqualTo(k₁, k₂).
  

• Речник АТД моделира възможности за търсене в колекция от двойки ключ-елемент.
• Основни операции за речник са търсене (find), вмъкване (добавяне, insert) и премахване (изтриване, delete).
• Допуска се няколко членове на речника да имат един и същи ключ.
• Приложения:
• книга с адреси (address book);
• авторизация на кредитни карти (credit card authorization);
• DNS съответствия [име на хост (напр.  www.nbu.bg) - интернет адрес (193.19.172.24)].
• Речник АТД използва позиции и поддържа следните функции:

• Бележки:
  
• Начинът, по който членовете на речника се съхраняват зависи от реализацията на речника.
• Означението p(x) показва позицията на члена, където се пази елемента x.
• Пример:

• Позиция АТД поддържа следните функции:

• Един прост начин за реализация на речник АТД е да използваме ненаредени вектор АТД, списък АТД или редица АТД за запазване на двойката ключ-елемент.
• Тази реализация се нарича log файл.

• Log файл е речник АТД, реализиран с несортирана редица.
• Съхраняваме членовете на речника в редица (базирана на двойносвързан списък или кръгов масив) в произволен ред.
• Performance:
• insertItem отнема време O(1), защото добавяме нов член в началото или в края на редицата.
• find и removeElement отнемат време O(n), защото в най-лошия случай (обектът не е намерен) трябва да обходим (претърсим) цялата редица, сравнявайки ключовете на членовете с дадения ключ.
• Log файлът е ефективен само за речници с малки размери или за речници, за които вмъкването са най-честата операция, докато търсене и изтриване се изпълняват рядко (напр., запис на историята потребителски имена на работна станция).
  

Хеш таблици

• Един от най-ефективните начини за реализация на речник АТД е използването на хеш таблица.
• Въпреки, че хеш таблици имат голямо време за изпълнение за операциите на речник АТД в най-лошия случай, ще видим, че тяхното очаквано време за изпълнение в повечето случаи е отлично.
• Ако n означава броя на обектите в речника, времето за работа в най-лошия случай е O(n), но очакваното време за работа в общия случай е само O(1).

• A клетъчен масив за хеш таблица е масив A с размер N (капацитет), където всеки елемент на A се разглежда като клетка (т.е. контейнер за двойката ключ-елемент).
• Ако ключовете са цели числа, добре разпределени в интервала [0, N - 1], този клетъчен масив е всичко, от което се нуждаем - елемент e с ключ k просто се вмъква в клетка A[k].
• Ако ключовете не са уникални, тогава два елемента може да попаднат е една и съща клетка от A. В този случай казваме, че се появява колизия.

• Достижение: O(1) за всички функции, няма колизии за различни ключове.
• Недостатък 1: Използва памет Theta(N), разточително когато N е голямо относно n.
• Недостатък 2: Ключовете са цели числа в интервала [0, N - 1], което често не е така.

• Хеш функция h изобразява ключове от даден тип  в цели числа от интервала [0, N − 1].
• Пример: h(x) = x mod N е хеш функция за цели числа.
• Цялото число h(x) се нарича хеш стойност на ключа x.
• Хеш таблица за даден тип ключове се състои от:
• хеш функция h,
  
• масив с размер N.
• Когато се реализира речник с хеш таблица, целта е да се постави обекта (k, e) в масива с индекс i =  h(k).
• Пример:

Да се направи хеш таблица за речник, съдържащ двойки (SSN, Name), където SSN (social security number) е 9-цифрово положително число. Ако хеш таблицата използва масив с размер N = 10000 и хеш функция h(x) = x mod 10000, т.е. (последните 4 цифри на x), може да възникнат колизии. За да се избегнат колизии, ще трябва да се вземе N = 109 и хеш функция h(x) = x (Недостатък 1).

• Хеш функцията h обикновено се разглежда като композиция на две функции:
  
• Хеш код: h₁: keys → integers
• Компресия: h₂: integers → [0, N − 1]
• Хеш кода се прилага първи и след това компресията се прилага върху резултата, т.е. h(x) = h₂(h₁(x)).
• Целта на хеш функцията е да "разпръсне" ключовете по (привидно) случаен начин.
• Хеш функцията е "добра", ако изобразява ключовете на речника така, че да минимизира колизиите.
• Тя трябва да бъде също така бърза и лесна за пресмятане.

• Цяло число, което съответства на ключа k се нарича хеш код или хеш стойност за k.

• Адреси на паметта:
  
• Обръща се (преобразува се) адреса в паметта на обекта-ключ в цяло число.
• Добър като цяло, с изключение на числови и низови ключове.
  
• Integer cast:
• Преобразуват се (reinterpret) битовете на ключа в цяло число.
  
• Подходящ за ключове с дължина по-малка или равна на броя на битовете на числовия тип (например, char, short, int и float за много машини).
  
• Сума на компонентите:
• Разделят се битовете на ключа на компоненти с фиксирана дължина (например 16 или 32 бита) и се сумират компонентите (игнорирайки евентуално препълване).
• Подходящ за числови ключове с фиксирана дължина, по-голяма или равна на броя на битовете на числовия тип (например,  long и double за много машини).

int hashCode(int x)
{ return x; }

int hashCode(long x)
{  typedef unsigned long ulong;
   return hashCode(static_cast<int>(static_cast<ulong>(x) >> 32) 
          + static_cast<int>(x));
}

• Полиномиално натрупване:
• Разделят се битовете на ключа на редица от компоненти с фиксирана дължина (например, 8, 16 или 32 бита): a₀ a₁… a_n−1.
• Пресмята се стойността на полинома
  p(z) = a₀ + a₁z + a₂ z^₂ + … + a_n−1z^_n−1
  за фиксирана стойност на z, игнорирайки препълването.
• Особено подходящ за низове (напр. изборът z = 33 дава най-много 6 колизии за множество от 50000 английски думи!)
• Стойността на полиномът p(z) се смята за време O(n) по схемата на Хорнер:
• Следните полиноми се изчисляват последователно, като всеки от предишния, за време O(1) -
  p₀(z) = a_n−1,  p_i(z) = a_n−i−1 + zp_i−1(z) (i = 1, 2, …, n − 1).
• Получаваме p(z) = p_n−1(z).

int hashCode(const char* p, int len) // hash a character array
{ unsigned int h = 0;
  for (int i = 0; i < len; i++)
  { h = (h << 5)|(h >> 27);          // 5-bit cyclic shift
    h += (unsigned int)p[i];         // add in next character
  }
  return hashCode(int(h));
}

int hashCode(const double& x)       // hash a double
{ int len = sizeof(x);
  const char* p = reinterpret_cast<const char *>(&x);
  return hashCode(p, len);
}

Компресиращи изображения

• Хеш кода за ключ k обикновено не е подходящ за незабавнo използване с употреба с клетъчния масив, тъй като интервалът от възможни хеш кодове за ключовете обикновено надвишава интервала за допустими индекси на масива.

• h₂(y) = | y | mod N.
• Размерът N на хеш таблицата обикновено се избира просто число.
  
• Причината за това е свързана с теорията на числата и е извън обхвата на този курс.

• h₂(y) = |ay + b| mod N
• a и b са неотрицателни числа, такива че a mod N ≠ 0.
• В противен случай, всяко число ще се изобразява в една и съща стойност b.

• Колизия възниква, когато различни елементи трябва да се поставят в една и съща клетка.

• Верижно съставяне: нека всяка клетка от таблицата е адрес на първия елемент на свързан списък.
• Верижно съставяне е просто, но изисква допълнителна памет извън таблицата.

Подход на отворено адресиране
Отворено адресиране: при колизия обектът се поставя в друга клетка на таблицата.

Линейно пробване (linear probing)

• Линейното пробване решава колизиите като поставя обекта в следващата свободна (кръгово) клетка на таблицата.
• Всяка проверена клетка на таблицата се разглежда като "проба".
• Обектите с колизии се струпват, като следващите колизии предизвикват по-дълги редици от проби.
• Пример:
  

h(x) = x mod 13 Добавяме ключове 18, 41, 22, 44, 59, 32, 31, 73 в този ред.

• За да се организира вмъквания и изтривания, се въвежда специален обект, наречен AVAILABLE (USED), който замества изтритите обекти.
• removeElement(k)
• Търси се обект с ключ k.
• Ако обектът (k, e) е намерен, той се замества със специалния обект AVAILABLE и се връща позицията му.
• В противен случай се връща nullposition.
• insertItem(k, e)
• Ако таблицата е пълна, се изхвърля изключение.
• Започва се с клетка h(k).
• Пробват се последователно клетките докато се появи един от следните случаи:
• намерена е клетка i, която е празна или съдържа AVAILABLE, или
  
• N клетки са пробвани без резултат.
• Поставя се обекта (k, e) в клетка i.

• Двойно хеширане използва втора хеш функция d(k) и обработва колизии чрез поставяне на обекта в първата свободна клетка от серията (i+ jd(k)) mod N за j = 0, 1, … , N −1.
• Втората хеш функция d(k) не трябва да има нулеви стойности.
• Размерът N на таблицата трябва да бъде просто число, за да може да се пробват всички клетки.
• За компресията на втората хеш функция обикновено се избира функцията d₂(k) = q − k mod q където
  
• q < N
  
• q е просто число.
  
• Възможни стойности на d₂(k) са 1, 2, … , q.
• Пример:

Разглеждаме хеш таблица за съхранение на целочислени ключове, обработваща колизии с двойно хеширане N = 13 h(k) = k mod 13 d(k) = 7 − k mod 7 Въвеждат се ключове 18, 41, 22, 44, 59, 32, 31, 73, в този ред.

Реализация на хеш-таблица със C++

• closestBefore(k) - Връща позиция на обект с най-голям ключ, по-малък или равен на k.
• closestAfter(k) - Връща позиция на обект с най-малкия ключ, по-голям или равен на k.

• Lookup таблица е речник, реализиран с наредена редица.
• Ще съхраняваме обектите на речника в масив базирана редица АТД, сортирани по ключ.
  
• Ще използваме външен компаратор за сравнение на ключовете.
• Performance:
• find отнема време O(log n), като използваме двоично търсене.
• insertItem отнема време O(n), защото в най-лошия случай преместваме n/2 обекта, за да направим място на новия обект.
• removeElement отнема време O(n),  защото в най-лошия случай преместваме n/2 обекта, за да запълним празното място след премахването.
• Lookup таблицата е ефективна само за речници с малки размери, или за речници, на която търсенето са най-честата операция, докато вмъкване и отстраняване са рядко изпълнявани (например, оторизация на кредитни карти).
  

• Двоичното търсене изпълнява операция find(k) за речник, реализиран с масив-базирана редица, наредена по ключове:
  
• на всяка стъпка броят на кандидатите се намалява наполовина;
• завършва за логаритмичен брой стъпки (относно големината на речника).
• Пример: find(7)

bsearch.cpp

Анализ на двоично търсене

• Времето за изпълнение е пропорционално на числото k на рекурсивните извиквания.
• Броят на оставащите кандидати се намалява най-малко наполовина с всяко рекурсивно извикване.
• В най-лошия случай (неуспешно търсене), рекурсията спира когато няма повече кандидати, т.е. n/2^k = 1, k = log n и получаваме време за изпълнение O(log n).