added string performance, boosted universal hash functions, added real life example, +fixes

Author: VirtualRoyalty

algorithm/include/ChainedHashMap.h

@@ -7,29 +7,33 @@
 // Hash map class template
 template <typename K, typename V> class HashMap {
 private:
- HashMap(const HashMap &other);
- const HashMap &operator=(const HashMap &other);
+ // HashMap(const HashMap &other);
+ // const HashMap &operator=(const HashMap &other);
  // std::vector<HashNode<K, V>*> *table;
  KeyHash<K> hashFunc;
  HashNode<K, V> **table; // int *ptr;
  VComparator<K> comp;
  size_t tableSize;
+ unsigned int collisions = 0;
 
 public:
  HashMap(const size_t tableSize) : hashFunc(tableSize), comp() {
  this->tableSize = tableSize;
  table = new HashNode<K, V> *[tableSize]();
  }
  bool insert(const K &key, const V &value) {
+ unsigned int attempt = 0;
  unsigned int hashValue = hashFunc[key];
  HashNode<K, V> *prev = NULL;
  HashNode<K, V> *entry = table[hashValue];
  // std::cout << "before while" << &entry <<std::endl;
  while (entry != NULL && !comp.compare(entry->getKey(), key)) {
  // std::cout << "entry != NULL" << std::endl;
+ ++attempt;
  prev = entry;
  entry = entry->getNext();
  }
+ collisions += attempt;
 
  if (entry == NULL) {
  // std::cout << "entry == NULL" << std::endl;
@@ -55,33 +59,34 @@ template <typename K, typename V> class HashMap {
  bool search(const K &key, V &value) {
  unsigned int hashValue = hashFunc[key];
  HashNode<K, V> *entry = table[hashValue];
- unsigned int ccounter = 0;
+ unsigned int attempt = 0;
  while (entry != NULL) {
- ccounter++;
- // std::cout << "hashkey: "<< hashValue << " value: " << entry->getValue()
- // <<std::endl;
+ ++attempt;
  if (comp.compare(entry->getKey(), key)) {
+ collisions += attempt;
  value = entry->getValue();
- // std::cout << "Number of tries: "<< ccounter <<std::endl;
  return true;
  }
-
  entry = entry->getNext();
  }
+ collisions += attempt;
  // std::cout << "Number of tries: "<< ccounter <<std::endl;
  // std::cout << "UKNOWN KEY!"<< std::endl;
  return false;
  }
 
  void remove(const K &key) {
+ unsigned int attempt = 0;
  unsigned int hashValue = hashFunc[key];
  HashNode<K, V> *prev = NULL;
  HashNode<K, V> *entry = table[hashValue];
 
  while (entry != NULL && !comp.compare(entry->getKey(), key)) {
+ ++attempt;
  prev = entry;
  entry = entry->getNext();
  }
+ collisions += attempt;
 
  if (entry == NULL) {
  // key not found
@@ -95,10 +100,14 @@ template <typename K, typename V> class HashMap {
  } else {
  prev->setNext(entry->getNext());
  }
-
  delete entry;
  }
  }
+
+ void resetCollisions(){ collisions = 0; }
+
+ unsigned int getNcollisions(){ return collisions; }
+
  // void displayHash() {
  // HashNode<K,V>* entry = NULL;
  // for (int i = 0; i < tableSize; i++) {

algorithm/include/ChainedHashMapOLD.h

@@ -16,7 +16,6 @@ template <typename K> class OpenKeyHash {
 private:
  size_t tableSize;
  KeyHash<K> uniHashFunc;
- KeyHash<K> uniHashFuncAUX;
  unsigned int prime = 101027;
  unsigned int c1 = 1;
  unsigned int c2 = 3;
@@ -26,7 +25,6 @@ template <typename K> class OpenKeyHash {
  OpenKeyHash(size_t tableSize, std::string hashType)
  : tableSize(tableSize),
  uniHashFunc(tableSize),
- uniHashFuncAUX(tableSize),
  hashType(hashType){};
 
  unsigned int operator[](KeyAttempt<K> const &pairKA) const {
@@ -40,12 +38,11 @@ template <typename K> class OpenKeyHash {
  return (l >= tableSize) ? l % tableSize : l;
  } else if (hashType == "DOUBLE") {
  unsigned int auxHash1 = uniHashFunc[pairKA.key];
- unsigned int auxHash2 = (PRIME[pairKA.key % 420]);//1 + (pairKA.key % 8);
+ unsigned int auxHash2 = (PRIME[pairKA.key % PRIME.size()]);
  unsigned int l = auxHash1 + (pairKA.attempt * auxHash2);
  return (l >= tableSize) ? l % tableSize : l;
  } else {
- unsigned int l = uniHashFunc[pairKA.key] + pairKA.attempt;
- return (l >= tableSize) ? l % tableSize : l;
+ throw;
  }
  }
 };
@@ -54,15 +51,14 @@ template <> class OpenKeyHash<std::string> {
 private:
  size_t tableSize;
  KeyHash<std::string> uniHashFunc;
- KeyHash<std::string> uniHashFuncAUX;
- unsigned int prime = 97;
  unsigned int c1 = 1;
  unsigned int c2 = 3;
  std::string hashType;
 
 public:
  OpenKeyHash(size_t tableSize, std::string hashType)
- : tableSize(tableSize), uniHashFunc(tableSize), uniHashFuncAUX(tableSize),
+ : tableSize(tableSize),
+ uniHashFunc(tableSize),
  hashType(hashType){};
 
  unsigned int operator[](KeyAttempt<std::string> const &pairKA) const {
@@ -80,8 +76,7 @@ template <> class OpenKeyHash<std::string> {
  unsigned int l = auxHash1 + pairKA.attempt * auxHash2;
  return (l >= tableSize) ? l % tableSize : l;
  } else {
- unsigned int l = uniHashFunc[pairKA.key] + pairKA.attempt;
- return (l >= tableSize) ? l % tableSize : l;
+ throw;
  }
  }
 };

algorithm/include/OpenedHash.h

@@ -9,12 +9,13 @@
 
 template <typename K, typename V> class OpenHashMap {
 private:
- OpenHashMap(const OpenHashMap &other);
- const OpenHashMap &operator=(const OpenHashMap &other);
+ // OpenHashMap(const OpenHashMap &other);
+ // const OpenHashMap &operator=(const OpenHashMap &other);
  size_t tableSize;
  OpenHashNode<K, V> **table;
  VComparator<K> comp;
  OpenKeyHash<K> hashFunc;
+ unsigned int collisions = 0;
 
 public:
  OpenHashMap(size_t tableSize, std::string hashType)
@@ -38,20 +39,21 @@ template <typename K, typename V> class OpenHashMap {
  OpenHashNode<K, V> *entry = table[hashValue];
  // std::cout <<"\nkey: " << key << " hash: " << hashValue << std::endl;
  while (entry != NULL && entry->getState() != DELETED) {
- attempt++;
  // std::cout << attempt << " ";
- pairKA.attempt = attempt;
+ pairKA.attempt = ++attempt;
  hashValue = hashFunc[pairKA];
  entry = table[hashValue];
  if (attempt > tableSize) {
  // std::cout << "Opened Hash Table is full! " << value << std::endl;
+ collisions += attempt;
  return false;
  }
  }
  if (entry == NULL) {
  // std::cout << "entry == NULL"<< std::endl;
  // std::cout << "entry set " << value << std::endl;
  table[hashValue] = new OpenHashNode<K, V>(key, value);
+ collisions += attempt;
  return true;
  } else if (entry->getState() == DELETED) {
  // std::cout << "entry == DELETED"<< std::endl;
@@ -61,6 +63,7 @@ template <typename K, typename V> class OpenHashMap {
  return true;
  } else {
  // std::cout << "entry set new value " << value << std::endl;
+ collisions += attempt;
  entry->setValue(value);
  return true;
  }
@@ -77,6 +80,7 @@ template <typename K, typename V> class OpenHashMap {
  if (entry->getState() != DELETED) {
  if (comp.compare(entry->getKey(), key)) {
  value = entry->getValue();
+ collisions += attempt;
  return true;
  }
  }
@@ -87,6 +91,7 @@ template <typename K, typename V> class OpenHashMap {
  // std::cout << "Opened Hash Table is full!";
  // std::cout << "Number of tries: "<< attempt <<std::endl;
  // std::cout << "UKNOWN KEY!"<< std::endl;
+ collisions += attempt;
  return false;
  }
  }
@@ -100,29 +105,35 @@ template <typename K, typename V> class OpenHashMap {
  OpenHashNode<K, V> *entry = table[hashValue];
 
  while (entry != NULL && !comp.compare(entry->getKey(), key)) {
- attempt++;
- pairKA.attempt = attempt;
+ pairKA.attempt = ++attempt;
  hashValue = hashFunc[pairKA]; //(hashFunc[key] + attempt) % tableSize;
  entry = table[hashValue];
- if (attempt > tableSize - 1) {
+ if (attempt >= tableSize) {
  // std::cout << "Opened Hash Table is full!";
  // std::cout << "Number of tries: "<< attempt <<std::endl;
  // std::cout << "UKNOWN KEY!"<< std::endl;
+ collisions += attempt;
  return;
  }
  }
 
  if (entry == NULL) {
  // std::cout << "Number of tries: "<< attempt <<std::endl;
  // std::cout << "UKNOWN KEY!"<< std::endl;
+ collisions += attempt;
  return;
 
  } else {
+ collisions += attempt;
  entry->setState(DELETED);
  entry->setState(DELETED);
  }
  }
 
+ void resetCollisions(){ collisions = 0; }
+
+ unsigned int getNcollisions(){ return collisions; }
+
  void displayHash() {
  std::cout << std::endl;
  for (int i = 0; i < tableSize; i++) {