Feedback

src/hash_table.cpp

@@ -18,26 +18,62 @@ namespace itis {
     }
 
     // Tip: allocate hash-table buckets
+    buckets_.resize(capacity);
   }
 
   std::optional<std::string> HashTable::Search(int key) const {
     // Tip: compute hash code (index) and use linear search
+    int index = hash(key);
+    for(auto bucket: buckets_[index]){
+      if(bucket.first == key) return bucket.second;
+    }
     return std::nullopt;
   }
 
   void HashTable::Put(int key, const std::string &value) {
     // Tip 1: compute hash code (index) to determine which bucket to use
     // Tip 2: consider the case when the key exists (read the docs in the header file)
+    int index = hash(key);
+    std::pair<int, std::string> bucket (key, value);
+    for(auto pair: buckets_[index]){
+      if (pair.empty()) {
+        pair.push_back(bucket);
+        num_keys_++;
+      }
+
+      else {
+        pair.second = value;
+      }
+    }
 
     if (static_cast<double>(num_keys_) / buckets_.size() >= load_factor_) {
       // Tip 3: recompute hash codes (indices) for key-value pairs (create a new hash-table)
       // Tip 4: use utils::hash(key, size) to compute new indices for key-value pairs
+      std::vector<Bucket> new_buckets_;
+      new_buckets_.resize(num_keys_*kGrowthCoefficient);
+      for(auto bucket: buckets_){
+        for(auto pair: bucket) {
+          int index = utils::hash(pair.first, static_cast<int>(new_buckets_.size()));
+          new_buckets_[index].push_back(pair);
+        }
+      }
+      buckets_.clear();
+      buckets_ = new_buckets_;
     }
   }
 
   std::optional<std::string> HashTable::Remove(int key) {
     // Tip 1: compute hash code (index) to determine which bucket to use
     // TIp 2: find the key-value pair to remove and make a copy of value to return
+    int index = hash(key);
+    for(auto pair: buckets_[index]){
+      if(pair.first == key){
+        auto value = pair.second;
+        buckets_[index].remove(pair);
+        num_keys_--;
+        return value;
+      }
+    }
     return std::nullopt;
   }