linking hashing implemented

Author: VirtualRoyalty

algorithm/include/HashMap.h

@@ -1,24 +1,26 @@
 #pragma once
 
+
 #include "KeyHash.h"
 #include "HashNode.h"
-
+#include "VComparator.h"
 
 // Hash map class template
-template <typename K, typename V, size_t tableSize, typename F = KeyHash<K, tableSize> >
+template <typename K, typename V, size_t tableSize>
 class HashMap
 {
 private:
  HashMap(const HashMap& other);
  const HashMap& operator=(const HashMap& other);
- // hash table
  HashNode<K, V>* table[tableSize];
- F hashFunc;
+ KeyHash<K> hashFunc;
+ VComparator<K> comp;
 
 public:
  HashMap() :
  table(),
- hashFunc()
+ hashFunc(tableSize),
+ comp()
  {
  }
 
@@ -38,30 +40,33 @@ class HashMap
  }
  }
 
- bool get(const K& key, V& value)
+ bool search(const K& key, V& value)
  {
- unsigned long hashValue = hashFunc(key);
+ unsigned long hashValue = hashFunc[key];
  HashNode<K, V>* entry = table[hashValue];
-
+ unsigned int ccounter = 0;
  while (entry != NULL) {
- if (entry->getKey() == key) {
+ ccounter++;
+ // std::cout << "hashkey: "<< hashValue << " value: " << entry->getValue() <<std::endl;
+ if (comp.compare(entry->getKey(), key)) {
  value = entry->getValue();
+ std::cout << "Number of tries: "<< ccounter <<std::endl;
  return true;
  }
 
  entry = entry->getNext();
  }
-
+ std::cout << "Number of tries: "<< ccounter <<std::endl;
+ std::cout << "UKNOWN KEY!"<< std::endl;
  return false;
  }
 
- void put(const K& key, const V& value)
+ void insert(const K& key, const V& value)
  {
- unsigned long hashValue = hashFunc(key);
+ unsigned long hashValue = hashFunc[key];
  HashNode<K, V>* prev = NULL;
  HashNode<K, V>* entry = table[hashValue];
-
- while (entry != NULL && entry->getKey() != key) {
+ while (entry != NULL && !comp.compare(entry->getKey(), key)) {
  prev = entry;
  entry = entry->getNext();
  }
@@ -87,11 +92,11 @@ class HashMap
 
  void remove(const K& key)
  {
- unsigned long hashValue = hashFunc(key);
+ unsigned long hashValue = hashFunc[key];
  HashNode<K, V>* prev = NULL;
  HashNode<K, V>* entry = table[hashValue];
 
- while (entry != NULL && entry->getKey() != key) {
+ while (entry != NULL && !comp.compare(entry->getKey(), key)) {
  prev = entry;
  entry = entry->getNext();
  }
@@ -114,4 +119,4 @@ class HashMap
  delete entry;
  }
  }
-};
+};

algorithm/include/HashNode.h

@@ -47,4 +47,4 @@ class HashNode
  {
  _next = next;
  }
-};
+};

algorithm/include/KeyHash.h

@@ -1,9 +1,64 @@
 #pragma once
+#include <random>
+#include <math.h>
 
-template <typename K, size_t tableSize>
-struct KeyHash {
- unsigned long operator()(const K& key) const
+template <typename K>
+class KeyHash{
+ private:
+ size_t tableSize;
+ public:
+ KeyHash(size_t tableSize){
+ this->tableSize = tableSize;
+ }
+ unsigned long operator[](const K& key) const
  {
- return reinterpret_cast<unsigned long>(key) % tableSize;
+ return reinterpret_cast<unsigned long>(key) % this->tableSize;
+ }
+
+};
+
+template <>
+class KeyHash<int>{
+ private:
+ size_t tableSize;
+ int a, b;
+ public:
+ KeyHash(size_t tableSize){
+ this->tableSize = tableSize;
+ std::mt19937 mers(42);
+ std::uniform_int_distribution<int> a_uid(1, this->tableSize-1);
+ std::uniform_int_distribution<int> b_uid(0, this->tableSize-1);
+ this->a = a_uid(mers);
+ this->b = b_uid(mers);
  }
-};
+ unsigned long operator[](const int& key) const
+ {
+ // std::cout << this->a <<" "<< this->b << std::endl;
+ return (this->a * key + this->b) % this->tableSize;
+ }
+
+};
+
+
+template <>
+class KeyHash<std::vector<int>>{
+ private:
+ size_t tableSize;
+ int a;
+ public:
+ KeyHash(size_t tableSize){
+ this->tableSize = tableSize;
+ std::mt19937 mers(42);
+ std::uniform_int_distribution<int> a_uid(1, this->tableSize-1);
+ this->a = a_uid(mers);
+ }
+ unsigned long operator[](const std::vector<int>& key) const
+ {
+ unsigned long hkey = 0;
+ for (int i=0; i<key.size(); i++){
+ hkey += ((int)pow(this->a, i) * key[i]) % this->tableSize;
+ }
+ return hkey % this->tableSize;
+ }
+
+};

algorithm/include/VComparator.h

@@ -0,0 +1,42 @@
+#pragma once
+#include <random>
+#include <math.h>
+#include <iostream>
+
+template <typename L>
+class VComparator
+{
+public:
+ VComparator(){};
+ bool compare(L a, L b) const{
+ return a == b;
+ }
+};
+
+template <>
+class VComparator<const int*>
+{
+public:
+ VComparator(){};
+ bool compare(const int* a, const int* b) const{
+ return a == b;
+ }
+};
+
+
+template <>
+class VComparator<std::vector<int>>
+{
+public:
+ VComparator(){};
+ bool compare(std::vector<int> a, std::vector<int> b){
+ if (a.size() != b.size())
+ return false;
+ for(auto i=0; i<a.size(); i++)
+ if (a[i] != b[i])
+ return false;
+ return true;
+
+ }
+
+};

algorithm/include/utils.h

@@ -4,4 +4,7 @@
 void write_csv(std::string filename, std::vector<std::pair<std::string, std::vector<int>>> dataset);
 std::vector<std::pair<std::string, std::vector<int>>> read_csv(std::string filename);
 
-std::vector<int> gen_rand_vec(int N);
+std::vector<int> genRandVec(int N);
+
+void testNumberLinkedHashMap();
+void testVectorLinkedHashMap();

algorithm/src/generators.cpp

@@ -6,16 +6,20 @@
 #include <random>
 #include <algorithm>
 
-std::vector<int> gen_rand_vec(int N){
- std::random_device rd;
- std::mt19937 mersenne(rd()); // инициализируем Вихрь Мерсенна случайным стартовым числом
 
- #include <vector>
 
+int genRandomUid(){
+ std::random_device rd;
+ std::mt19937 mersenne(rd()); // инициализируем Вихрь Мерсенна случайным стартовым числом
+ std::uniform_int_distribution<int> uid(0, 1000);
+ return uid(mersenne);
+}
 
- std::vector<int> rand_vec(N);
- std::generate(rand_vec.begin(), rand_vec.end(), mersenne);
+std::vector<int> genRandVec(int N){
 
+ std::vector<int> randVec(N);
+ std::generate(randVec.begin(), randVec.end(), genRandomUid);
 
- return rand_vec;
+
+ return randVec;
  }

algorithm/src/main.cpp

@@ -3,33 +3,25 @@
 #include <fstream>
 #include <vector>
 #include <utility>
+#include <random>
 
 #include "utils.h"
-
+#include "VComparator.h"
 #include "HashNode.h"
 #include "KeyHash.h"
 #include "HashMap.h"
 
-const size_t tableSize = 5;
-
-struct MyKeyHash {
- unsigned long operator()(const int& key) const
- {
- return key % tableSize;
- }
-};
-
 
 int main() {
  // Make three vectors, each of length 100 filled with 1s, 2s, and 3s
- std::vector<int> vec1(10, 1);
- std::vector<int> vec2(10, 2);
- std::vector<int> vec3(10, 3);
-
- // Wrap into a vector
- std::vector<std::pair<std::string, std::vector<int>>> vals = { {"First", vec1}, {"Second", vec2}, {"Three", vec3} };
-
- std::string filepath = "../../data/output/example.csv";
+ // std::vector<int> vec1(10, 1);
+ // std::vector<int> vec2(10, 2);
+ // std::vector<int> vec3(10, 3);
+ //
+ // // Wrap into a vector
+ // std::vector<std::pair<std::string, std::vector<int>>> vals = { {"First", vec1}, {"Second", vec2}, {"Three", vec3} };
+ //
+ // std::string filepath = "../../data/outinsert/example.csv";
  // Write the vector to CSV
  /*
  write_csv(filepath, vals);
@@ -49,27 +41,12 @@ int main() {
  }
  */
 
- //test simple hash map
- HashMap <int, std::string, tableSize, MyKeyHash> hmap;
-
- hmap.put(1, "val1");
- hmap.put(2, "val2");
- hmap.put(6, "val3");
- hmap.put(7, "val4");
+ //test integer number hashing()
+ // std::cout << "Linked Hashing Numbers:\n";
+ // testNumberLinkedHashMap();
+ //test vector of integer number hashing()
+ std::cout << "Linked Hashing Vectors:\n";
+ testVectorLinkedHashMap();
 
- std::string value;
- hmap.get(6, value);
- std::cout << value << std::endl;
- bool res = hmap.get(3, value);
- if (res)
- std::cout << value << std::endl;
- /* hmap.remove(3);
- res = hmap.get(3, value);
- if (res)
- cout << value << endl;*/
- std::vector<int> rand_vec(20);
- rand_vec = gen_rand_vec(20);
- for(auto const& value: rand_vec)
- std::cout << value << " " << std::endl;
  return 0;
 }

algorithm/src/testNumber.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <vector>
+#include <random>
+
+#include "utils.h"
+#include "HashMap.h"
+
+
+void testNumberLinkedHashMap()
+{
+ std::cout << "\nEnter tableSize: ";
+ const auto tableSize = 71;
+
+ std::size_t vecSize;
+ std::cout << "\nEnter vecSize: ";
+ std::cin >> vecSize;
+ std::vector<int> randVec(vecSize);
+ randVec = genRandVec(vecSize);
+
+ // building hasgMap
+ HashMap <int, int, tableSize> hmap;
+ for(auto const& value: randVec){
+ std::cout << value << std::endl;
+ hmap.insert(value, value);
+ }
+
+ while(true){
+ int value;
+ std::cout << "\nEnter key: ";
+ std::cin >> value;
+ if (value == -1){
+ break;
+ }
+ hmap.search(value, value);
+ }
+
+};