Merge pull request #11 from CodeSopranos/vadik_alp/dev

Vadik alp/dev

Author: VirtualRoyalty

algorithm/include/LinkedHashMap.h renamed to algorithm/include/ChainedHashMap.h

@@ -2,7 +2,7 @@
 #include <list>
 #include "VComparator.h"
 #include "UniversalHash.h"
-#include "LinkedHashNode.h"
+#include "ChainedHashNode.h"
 
 
 // Hash map class template
@@ -28,7 +28,7 @@ class HashMap
  }
  bool insert(const K& key, const V& value)
  {
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  HashNode<K, V>* prev = NULL;
  HashNode<K, V>* entry = table[hashValue];
  // std::cout << "before while" << &entry <<std::endl;
@@ -63,7 +63,7 @@ class HashMap
  }
  bool search(const K& key, V& value)
  {
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  HashNode<K, V>* entry = table[hashValue];
  unsigned int ccounter = 0;
  while (entry != NULL) {
@@ -84,7 +84,7 @@ class HashMap
 
 void remove(const K& key)
 {
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  HashNode<K, V>* prev = NULL;
  HashNode<K, V>* entry = table[hashValue];
 
@@ -111,17 +111,17 @@ void remove(const K& key)
  delete entry;
  }
  }
- void displayHash() {
- HashNode<K,V>* entry = NULL;
- for (int i = 0; i < tableSize; i++) {
- entry = table[i];
- std::cout << i;
- while (entry != NULL) {
- std::cout << " -> " << entry->getKey();
- entry = entry->getNext();
- }
- std::cout << std::endl;
- }
- }
+ //  void displayHash() {
+ //  HashNode<K,V>* entry = NULL;
+ //  for (int i = 0; i < tableSize; i++) {
+ //  entry = table[i];
+ //  std::cout << i;
+ //  while (entry != NULL) {
+ //  std::cout << " -> " << entry->getKey();
+ //  entry = entry->getNext();
+ //  }
+ //  std::cout << std::endl;
+ //  }
+ // }
 
 };

algorithm/include/LinkedHashMapOLD.h renamed to algorithm/include/ChainedHashMapOLD.h

@@ -2,7 +2,7 @@
 
 #include "VComparator.h"
 #include "UniversalHash.h"
-#include "LinkedHashNode.h"
+#include "ChainedHashNode.h"
 
 
 // Hash map class template
@@ -42,7 +42,7 @@ class HashMap
 
  bool search(const K& key, V& value)
  {
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  HashNode<K, V>* entry = table[hashValue];
  unsigned int ccounter = 0;
  while (entry != NULL) {
@@ -63,7 +63,7 @@ class HashMap
 
  void insert(const K& key, const V& value)
  {
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  HashNode<K, V>* prev = NULL;
  HashNode<K, V>* entry = table[hashValue];
  // std::cout << "before while" << entry <<std::endl;
@@ -93,7 +93,7 @@ class HashMap
 
  void remove(const K& key)
  {
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  HashNode<K, V>* prev = NULL;
  HashNode<K, V>* entry = table[hashValue];
 

algorithm/include/LinkedHashNode.h renamed to algorithm/include/ChainedHashNode.h

@@ -21,7 +21,9 @@ class OpenKeyHash
  size_t tableSize;
  KeyHash<K> uniHashFunc;
  KeyHash<K> uniHashFuncAUX;
- unsigned int p = 101027;
+ unsigned int prime= 101027;
+ unsigned int c1 = 11;
+ unsigned int c2 = 7;
  std::string hashType;
  public:
  OpenKeyHash(size_t tableSize, std::string hashType) :
@@ -30,16 +32,69 @@ class OpenKeyHash
  uniHashFuncAUX(tableSize),
  hashType(hashType){};
 
- unsigned long operator[](KeyAttempt<K> const& pairKA) const
+ unsigned int 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;
+ ((pairKA.attempt * c1) % prime) +
+ ((pairKA.attempt * pairKA.attempt * c2) % prime))
+ % tableSize;
+ }
+ else if (hashType == "DOUBLE")
+ {
+ unsigned int auxHash1 = uniHashFunc[pairKA.key];
+ // unsigned int auxHash2 = pairKA.key[0]; // ((auxHash1 << 1) >> 2);///(auxHash1 % 2) + (auxHash1 / 2); //(auxHash1 >> 1);
+ unsigned int l = auxHash1 + pairKA.attempt * (2*(pairKA.key % 1071)) ;//* auxHash2;
+ return (l >= tableSize) ? l % tableSize : l;
+ }
+ else{
+ return (uniHashFunc[pairKA.key] + pairKA.attempt) % tableSize;
+ }
+ }
+};
+
+
+template <>
+class OpenKeyHash<std::string>
+{
+ private:
+ size_t tableSize;
+ KeyHash<std::string> uniHashFunc;
+ KeyHash<std::string> uniHashFuncAUX;
+ unsigned int prime= 97;
+ unsigned int c1 = 11;
+ unsigned int c2 = 7;
+ std::string hashType;
+ public:
+ OpenKeyHash(size_t tableSize, std::string hashType) :
+ tableSize(tableSize),
+ uniHashFunc(tableSize),
+ uniHashFuncAUX(tableSize),
+ hashType(hashType){};
+
+ unsigned int operator[](KeyAttempt<std::string> const& pairKA) const
+ {
+ if (hashType == "LINEAR"){
+ unsigned int l = uniHashFunc[pairKA.key] + pairKA.attempt;
+ return (l >= tableSize) ? l % tableSize : l;
+ }
+ else if (hashType == "QUADRATIC")
+ {
+ return (uniHashFunc[pairKA.key] +
+ ((pairKA.attempt * c1) % tableSize) +
+ ((pairKA.attempt * pairKA.attempt * c2) % tableSize))
+ % tableSize;
+ }
+ else if (hashType == "DOUBLE")
+ {
+ unsigned int auxHash1 = uniHashFunc[pairKA.key];
+ unsigned int auxHash2 = auxHash1 % 2 + auxHash1;
+ unsigned int l = auxHash1 + pairKA.attempt * auxHash2;
+ return (l >= tableSize) ? l % tableSize : l;
  }
  else{
  return (uniHashFunc[pairKA.key] + pairKA.attempt) % tableSize;

algorithm/include/OpenedHash.h

@@ -6,7 +6,7 @@
 #include "OpenedHash.h"
 
 
-const int DELETED = -1;
+#define DELETED true
 
 template <typename K, typename V>
 class OpenHashMap
@@ -41,36 +41,38 @@ class OpenHashMap
  {
  unsigned int attempt = 0;
  KeyAttempt<K> pairKA = {key, attempt};
- unsigned long hashValue = hashFunc[pairKA];
+ unsigned int hashValue = hashFunc[pairKA];
  OpenHashNode<K, V>* entry = table[hashValue];
  // std::cout <<"\nkey: " << key << " hash: " << hashValue << std::endl;
- while (entry != NULL && entry->getKey() != DELETED) {
+ while (entry != NULL && entry->getState() != DELETED) {
  attempt++;
  // std::cout << attempt << " ";
  pairKA.attempt = attempt;
  hashValue = hashFunc[pairKA];
  entry = table[hashValue];
- if (attempt >= tableSize-1)
+ if (attempt > tableSize)
  {
- // std::cout << "Opened Hash Table is full!";
+ // std::cout << "Opened Hash Table is full! " << value << std::endl;
  return false;
 
  }
  }
  if (entry == NULL) {
  // std::cout << "entry == NULL"<< std::endl;
+ // std::cout << "entry set " << value << std::endl;
  entry = new OpenHashNode<K, V>(key, value);
  table[hashValue] = entry;
  return true;
  }
- else if (entry->getKey() == DELETED) {
+ else if (entry->getState() == DELETED) {
  // std::cout << "entry == DELETED"<< std::endl;
  entry->setKey(key);
  entry->setValue(value);
+ entry->setState(!DELETED);
  return true;
  }
  else {
- // std::cout << "entry set new value" << std::endl;
+ // std::cout << "entry set new value " << value << std::endl;
  entry->setValue(value);
  return true;
  }
@@ -80,19 +82,21 @@ class OpenHashMap
  {
  unsigned int attempt = 0;
  KeyAttempt<K> pairKA = {key, attempt};
- unsigned long hashValue = hashFunc[pairKA];
+ unsigned int hashValue = hashFunc[pairKA];
  OpenHashNode<K, V>* entry = table[hashValue];
  while (entry != NULL) {
  // std::cout << "hashkey: "<< hashValue << " value: " << entry->getValue() <<std::endl;
- if (comp.compare(entry->getKey(), key)) {
+ if (entry->getState() != DELETED) {
+ if (comp.compare(entry->getKey(), key)) {
  value = entry->getValue();
  return true;
+ }
  }
  attempt++;
  pairKA.attempt = attempt;
  hashValue = hashFunc[pairKA];//(hashFunc[key, attempt] + 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;
@@ -109,15 +113,15 @@ class OpenHashMap
  {
  unsigned int attempt = 0;
  KeyAttempt<K> pairKA = {key, attempt};
- unsigned long hashValue = hashFunc[pairKA];
+ unsigned int hashValue = hashFunc[pairKA];
  OpenHashNode<K, V>* entry = table[hashValue];
 
  while (entry != NULL && !comp.compare(entry->getKey(), key)) {
  attempt++;
  pairKA.attempt = attempt;
  hashValue = hashFunc[pairKA];//(hashFunc[key] + attempt) % tableSize;
  entry = table[hashValue];
- if (attempt >= tableSize-1)
+ if (attempt > tableSize-1)
  {
  // std::cout << "Opened Hash Table is full!";
  // std::cout << "Number of tries: "<< attempt <<std::endl;
@@ -134,8 +138,25 @@ class OpenHashMap
 
  }
  else {
- entry -> setKey(DELETED);
- entry -> setValue(DELETED);
+ entry -> setState(DELETED);
+ entry -> setState(DELETED);
  }
  }
+
+ void displayHash() {
+ std::cout << std::endl;
+ for (int i = 0; i < tableSize; i++) {
+ std::cout << i;
+ if (table[i]){
+ if (!table[i]->getState())
+ std::cout << " -> " << table[i]->getKey() << std::endl;
+ else
+ std::cout << " -> NULL (DELETED)" << std::endl;
+ }
+ else
+ std::cout << " -> NULL" << std::endl;
+ }
+
+ std::cout << std::endl;
+ }
 };

algorithm/include/OpenedHashMap.h

@@ -37,7 +37,7 @@ class OpenHashMap
  bool insert(const K& key, const V& value)
  {
  unsigned int attempt = 0;
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  OpenHashNode<K, V>* entry = table[hashValue];
  // std::cout <<"\nkey: " << key << " hash: " << hashValue << std::endl;
  while (entry != NULL && entry->getKey() != DELETED) {
@@ -74,7 +74,7 @@ class OpenHashMap
  bool search(const K& key, V& value)
  {
  unsigned int attempt = 0;
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  OpenHashNode<K, V>* entry = table[hashValue];
  while (entry != NULL) {
  // std::cout << "hashkey: "<< hashValue << " value: " << entry->getValue() <<std::endl;
@@ -101,7 +101,7 @@ class OpenHashMap
  void remove(const K& key)
  {
  unsigned int attempt = 0;
- unsigned long hashValue = hashFunc[key];
+ unsigned int hashValue = hashFunc[key];
  OpenHashNode<K, V>* entry = table[hashValue];
 
  while (entry != NULL && !comp.compare(entry->getKey(), key)) {

algorithm/include/OpenedHashMapOLD.h

@@ -7,6 +7,7 @@ class OpenHashNode
 private:
  K _key;
  V _value;
+ bool isDeleted = false;
  // OpenHashNode(const OpenHashNode&);
  // OpenHashNode& operator=(const OpenHashNode&);
 
@@ -35,4 +36,15 @@ class OpenHashNode
  {
  _key = key;
  }
+
+ void setState(bool state)
+ {
+ isDeleted = state;
+ }
+
+ bool getState() const
+ {
+ return isDeleted;
+ }
+
 };