opened hash template added, quadratic and linear hashing implemented

Author: VirtualRoyalty

algorithm/include/OpenedHash.h

@@ -0,0 +1,48 @@
+#pragma once
+#include <random>
+#include <math.h>
+#include <string>
+
+#include "UniversalHash.h"
+
+
+template<typename T>
+struct KeyAttempt
+{
+ const T& key;
+ unsigned int attempt;
+};
+
+
+template <typename K>
+class OpenKeyHash
+{
+ private:
+ size_t tableSize;
+ KeyHash<K> uniHashFunc;
+ KeyHash<K> uniHashFuncAUX;
+ unsigned int p = 101027;
+ std::string hashType;
+ public:
+ OpenKeyHash(size_t tableSize, std::string hashType) :
+ tableSize(tableSize),
+ uniHashFunc(tableSize),
+ uniHashFuncAUX(tableSize),
+ hashType(hashType){};
+
+ unsigned long operator[](KeyAttempt<K> const& pairKA) const
+ {
+ if (hashType == "LINEAR"){
+ return (uniHashFunc[pairKA.key] + pairKA.attempt) % tableSize;
+ }
+ else if (hashType == "QUADRATIC")
+ {
+ return (uniHashFunc[pairKA.key] +
+ ((pairKA.attempt * pairKA.key) % p) +
+ ((pairKA.attempt * pairKA.attempt * pairKA.key) % p)) % tableSize;
+ }
+ else{
+ return (uniHashFunc[pairKA.key] + pairKA.attempt) % tableSize;
+ }
+ }
+};

algorithm/include/OpenedHashMap.h

@@ -3,6 +3,8 @@
 #include "VComparator.h"
 #include "UniversalHash.h"
 #include "OpenedHashNode.h"
+#include "OpenedHash.h"
+
 
 const int DELETED = -1;
 
@@ -15,14 +17,13 @@ class OpenHashMap
  size_t tableSize;
  OpenHashNode<K, V>** table;
  VComparator<K> comp;
- KeyHash<K> hashFunc;
-
+ OpenKeyHash<K> hashFunc;
 public:
- OpenHashMap(size_t tableSize):
- hashFunc(tableSize),
+ OpenHashMap(size_t tableSize, std::string hashType):
+ tableSize(tableSize),
+ hashFunc(tableSize, hashType),
  comp()
  {
- this->tableSize = tableSize;
  table = new OpenHashNode<K, V>*[tableSize]();
  }
 
@@ -39,13 +40,15 @@ class OpenHashMap
  bool insert(const K& key, const V& value)
  {
  unsigned int attempt = 0;
- unsigned long hashValue = hashFunc[key];
+ KeyAttempt<K> pairKA = {key, attempt};
+ unsigned long hashValue = hashFunc[pairKA];
  OpenHashNode<K, V>* entry = table[hashValue];
  // std::cout <<"\nkey: " << key << " hash: " << hashValue << std::endl;
  while (entry != NULL && entry->getKey() != DELETED) {
  attempt++;
  // std::cout << attempt << " ";
- hashValue = (hashFunc[key] + attempt) % tableSize;
+ pairKA.attempt = attempt;
+ hashValue = hashFunc[pairKA];
  entry = table[hashValue];
  if (attempt >= tableSize-1)
  {
@@ -76,7 +79,8 @@ class OpenHashMap
  bool search(const K& key, V& value)
  {
  unsigned int attempt = 0;
- unsigned long hashValue = hashFunc[key];
+ KeyAttempt<K> pairKA = {key, attempt};
+ unsigned long hashValue = hashFunc[pairKA];
  OpenHashNode<K, V>* entry = table[hashValue];
  while (entry != NULL) {
  // std::cout << "hashkey: "<< hashValue << " value: " << entry->getValue() <<std::endl;
@@ -85,7 +89,8 @@ class OpenHashMap
  return true;
  }
  attempt++;
- hashValue = (hashFunc[key] + attempt) % tableSize;
+ pairKA.attempt = attempt;
+ hashValue = hashFunc[pairKA];//(hashFunc[key, attempt] + attempt) % tableSize;
  entry = table[hashValue];
  if (attempt >= tableSize-1)
  {
@@ -103,12 +108,14 @@ class OpenHashMap
  void remove(const K& key)
  {
  unsigned int attempt = 0;
- unsigned long hashValue = hashFunc[key];
+ KeyAttempt<K> pairKA = {key, attempt};
+ unsigned long hashValue = hashFunc[pairKA];
  OpenHashNode<K, V>* entry = table[hashValue];
 
  while (entry != NULL && !comp.compare(entry->getKey(), key)) {
  attempt++;
- hashValue = (hashFunc[key] + attempt) % tableSize;
+ pairKA.attempt = attempt;
+ hashValue = hashFunc[pairKA];//(hashFunc[key] + attempt) % tableSize;
  entry = table[hashValue];
  if (attempt >= tableSize-1)
  {

algorithm/include/OpenedHashNode.h

@@ -12,9 +12,10 @@ class OpenHashNode
 
 public:
  OpenHashNode(const K& key, const V& value) :
- _key(key), _value(value)
- {
- }
+ _key(key),
+ _value(value)
+ {}
+
  K getKey() const
  {
  return _key;

algorithm/include/UniversalHash.h

@@ -8,9 +8,8 @@ class KeyHash{
  private:
  size_t tableSize;
  public:
- KeyHash(size_t tableSize){
- this->tableSize = tableSize;
- }
+ KeyHash(size_t tableSize) : tableSize(tableSize) {}
+
  unsigned long operator[](const K& key) const
  {
  return reinterpret_cast<unsigned long>(key) % this->tableSize;

algorithm/src/main.cpp

@@ -29,9 +29,9 @@ int main() {
 
  // performance evaluation
  std::cout << "\n\n****Integer Numbers Hashing******";
- // getPerformanceInteger();
+ getPerformanceInteger();
  // getPerformanceIntegerLoop();
- getPerformanceIntegerToFile();
+ // getPerformanceIntegerToFile();
  //
  //
  // std::cout << "\n\n****Integer Vectors Hashing******";