feat: add grouped finder

QVectorSearch/mainwindow.cpp

@@ -2,6 +2,7 @@
 #include "./ui_mainwindow.h"
 
 #include "finder.h"
+#include "grouped_finder.h"
 #include "linear_finder.h"
 #include "parallel_finder.h"
 #include "timer.h"
@@ -28,6 +29,7 @@ void MainWindow::setupAlgorithmSelector() {
   search_algorithms_.appendRow(new QStandardItem("Linear search"));
   search_algorithms_.appendRow(new QStandardItem("Parallel search"));
   search_algorithms_.appendRow(new QStandardItem("Tree search"));
+  search_algorithms_.appendRow(new QStandardItem("Grouped search"));
 }
 
 void MainWindow::generateWordList() {
@@ -74,6 +76,9 @@ void MainWindow::createSelectedFinder() {
   case 2:
     finder_ = std::make_unique<TreeFinder>(word_list_);
     break;
+  case 3:
+    finder_ = std::make_unique<GroupedFinder>(word_list_);
+    break;
   }
 }
 

lib_vector_search/CMakeLists.txt

@@ -16,7 +16,9 @@ add_library(
   src/parallel_finder.cpp
   include/parallel_finder.h
   src/tree_finder.cpp
-  include/tree_finder.h)
+  include/tree_finder.h
+  src/grouped_finder.cpp
+  include/grouped_finder.h)
 
 target_include_directories(vector_search PUBLIC ${PROJECT_SOURCE_DIR}/include)
 

lib_vector_search/include/grouped_finder.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "finder.h"
+
+#include <map>
+#include <vector>
+
+class GroupedFinder : public Finder {
+private:
+  std::map<char, std::vector<const std::string *>> groups_;
+
+public:
+  GroupedFinder(const std::vector<string> &word_list);
+
+  virtual std::forward_list<const std::string *>
+  find_prefix(std::string_view search_term) const override;
+};

lib_vector_search/src/grouped_finder.cpp

@@ -0,0 +1,64 @@
+#include "grouped_finder.h"
+
+#include <mutex>
+#include <thread>
+#include <vector>
+
+using std::mutex, std::vector, std::thread, std::lock_guard;
+
+GroupedFinder::GroupedFinder(const std::vector<string> &word_list) {
+  for (const auto &word : word_list) {
+    groups_[word.front()].push_back(&word);
+  }
+}
+
+std::forward_list<const std::string *>
+GroupedFinder::find_prefix(std::string_view search_term) const {
+  const auto group = groups_.find(search_term.front());
+  if (group == groups_.cend()) {
+    return {};
+  }
+
+  const auto word_list = group->second;
+  const auto word_list_size = word_list.size();
+
+  const auto thread_count = std::thread::hardware_concurrency();
+
+  forward_list<const string *> matching_words;
+  mutex matching_words_mutex;
+
+  vector<thread> search_threads;
+  for (size_t thread_index = 0; thread_index < thread_count; ++thread_index) {
+    const size_t first_word_index =
+        thread_index * (word_list_size / thread_count);
+    const size_t last_word_index =
+        (thread_index == thread_count - 1)
+            ? word_list_size
+            : (thread_index + 1) * (word_list_size / thread_count);
+
+    search_threads.emplace_back(
+        [](const vector<const string *> &word_list,
+           const string_view &search_term, forward_list<const string *> &result,
+           size_t start_index, size_t end_index, mutex &result_mutex) {
+          forward_list<const string *> thread_results;
+          for (size_t index = start_index; index < end_index; ++index) {
+            const auto &current_word = word_list[index];
+            if (current_word->starts_with(search_term)) {
+              thread_results.push_front(current_word);
+            }
+          }
+          if (!thread_results.empty()) {
+            const lock_guard<mutex> lock(result_mutex);
+            result.merge(thread_results);
+          }
+        },
+        cref(word_list), cref(search_term), ref(matching_words),
+        first_word_index, last_word_index, ref(matching_words_mutex));
+  }
+
+  for (auto &thread : search_threads) {
+    thread.join();
+  }
+
+  return matching_words;
+}