QVectorSearch/mainwindow.cpp

@@ -5,7 +5,6 @@
 #include "grouped_finder.h"
 #include "linear_finder.h"
 #include "parallel_finder.h"
-#include "sorted_linear_finder.h"
 #include "timer.h"
 #include "tree_finder.h"
 #include "word_list_generator.h"
@@ -27,7 +26,6 @@ MainWindow::~MainWindow() { delete ui; }
 
 void MainWindow::setupAlgorithmSelector() {
   search_algorithms_.appendRow(new QStandardItem("Linear search"));
-  search_algorithms_.appendRow(new QStandardItem("Sorted linear search"));
   search_algorithms_.appendRow(new QStandardItem("Parallel search"));
   search_algorithms_.appendRow(new QStandardItem("Tree search"));
   search_algorithms_.appendRow(new QStandardItem("Grouped search"));
@@ -71,15 +69,12 @@ void MainWindow::createSelectedFinder() {
     finder_ = std::make_unique<LinearFinder>(word_list_);
     break;
   case 1:
-    finder_ = std::make_unique<SortedLinearFinder>(word_list_);
-    break;
-  case 2:
     finder_ = std::make_unique<ParallelFinder>(word_list_);
     break;
-  case 3:
+  case 2:
     finder_ = std::make_unique<TreeFinder>(word_list_);
     break;
-  case 4:
+  case 3:
     finder_ = std::make_unique<GroupedFinder>(word_list_);
     break;
   }

lib_vector_search/CMakeLists.txt

@@ -13,8 +13,6 @@ add_library(
   include/timer.h
   src/linear_finder.cpp
   include/linear_finder.h
-  src/sorted_linear_finder.cpp
-  include/sorted_linear_finder.h
   src/parallel_finder.cpp
   include/parallel_finder.h
   src/tree_finder.cpp

lib_vector_search/include/finder.h

@@ -3,10 +3,12 @@
 #include <forward_list>
 #include <string>
 
+using std::string, std::string_view, std::forward_list;
+
 class Finder {
 public:
   virtual ~Finder() = default;
 
-  virtual std::forward_list<const std::string *>
-  find_prefix(std::string_view search_term) const = 0;
+  virtual forward_list<const string *>
+  find_prefix(string_view search_term) const = 0;
 };

lib_vector_search/include/grouped_finder.h

@@ -10,7 +10,7 @@ private:
   std::map<char, std::vector<const std::string *>> groups_;
 
 public:
-  GroupedFinder(const std::vector<std::string> &word_list);
+  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/include/linear_finder.h

@@ -8,10 +8,10 @@ using std::vector;
 
 class LinearFinder : public Finder {
 private:
-  const vector<std::string> &word_list_;
+  const vector<string> &word_list_;
 
 public:
-  LinearFinder(const vector<std::string> &word_list);
-  std::forward_list<const std::string *>
-  find_prefix(std::string_view search_term) const override;
+  LinearFinder(const vector<string> &word_list);
+  forward_list<const string *>
+  find_prefix(string_view search_term) const override;
 };

lib_vector_search/include/parallel_finder.h

@@ -6,10 +6,10 @@
 
 class ParallelFinder : public Finder {
 private:
-  const std::vector<std::string> &word_list_;
+  const std::vector<string> &word_list_;
 
 public:
-  ParallelFinder(const std::vector<std::string> &word_list);
+  ParallelFinder(const std::vector<string> &word_list);
 
   std::forward_list<const std::string *>
   find_prefix(std::string_view search_term) const override;

lib_vector_search/include/sorted_linear_finder.h

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

lib_vector_search/include/tree_finder.h

@@ -11,7 +11,7 @@ private:
   std::map<const char, SearchTreeNode> children_;
 
 public:
-  void insert(std::string_view partial_word, const std::string *original_word);
+  void insert(std::string_view partial_word, const string *original_word);
   const SearchTreeNode *find(std::string_view search_term) const;
 
   std::forward_list<const std::string *> words() const;
@@ -27,7 +27,7 @@ private:
   SearchTree search_tree_;
 
 public:
-  TreeFinder(const std::vector<std::string> &word_list);
+  TreeFinder(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

@@ -1,12 +1,10 @@
 #include "grouped_finder.h"
 
-#include <forward_list>
 #include <mutex>
 #include <thread>
 #include <vector>
 
-using std::mutex, std::vector, std::thread, std::lock_guard, std::string,
-    std::forward_list, std::string_view;
+using std::mutex, std::vector, std::thread, std::lock_guard;
 
 GroupedFinder::GroupedFinder(const std::vector<string> &word_list) {
   for (const auto &word : word_list) {

lib_vector_search/src/linear_finder.cpp

@@ -1,8 +1,4 @@
 #include "linear_finder.h"
-#include <forward_list>
-#include <string_view>
-
-using std::string, std::forward_list, std::string_view;
 
 LinearFinder::LinearFinder(const vector<string> &word_list)
     : word_list_(word_list) {}

lib_vector_search/src/parallel_finder.cpp

@@ -3,8 +3,7 @@
 #include <mutex>
 #include <thread>
 
-using std::mutex, std::thread, std::lock_guard, std::vector, std::forward_list,
-    std::string, std::string_view;
+using std::mutex, std::thread, std::lock_guard, std::vector, std::forward_list;
 
 ParallelFinder::ParallelFinder(const vector<string> &word_list)
     : word_list_(word_list) {}

lib_vector_search/src/sorted_linear_finder.cpp

@@ -1,32 +0,0 @@
-#include "sorted_linear_finder.h"
-
-#include <algorithm>
-#include <iterator>
-
-using std::vector, std::forward_list, std::string, std::string_view;
-
-SortedLinearFinder::SortedLinearFinder(const vector<string> &word_list) {
-  std::transform(word_list.cbegin(), word_list.cend(),
-                 std::back_inserter(word_list_),
-                 [](const string &word) { return &word; });
-
-  std::sort(
-      word_list_.begin(), word_list_.end(),
-      [](const string *left, const string *right) { return *left < *right; });
-}
-forward_list<const string *>
-SortedLinearFinder::find_prefix(string_view search_term) const {
-  forward_list<const string *> matching_words;
-
-  bool in_range = false;
-  for (const auto *word : word_list_) {
-    if (word->starts_with(search_term)) {
-      matching_words.push_front(word);
-      in_range = true;
-    } else if (in_range) {
-      break;
-    }
-  }
-
-  return matching_words;
-}

lib_vector_search/src/tree_finder.cpp

@@ -1,19 +1,17 @@
 #include "tree_finder.h"
 
-using std::string, std::string_view, std::forward_list, std::vector;
-
-void SearchTreeNode::insert(string_view partial_word,
+void SearchTreeNode::insert(std::string_view partial_word,
                             const string *original_word) {
   if (partial_word.empty()) {
     words_.push_front(original_word);
   } else {
     children_[partial_word.front()].insert(
-        string_view(partial_word).substr(1, partial_word.length()),
+        std::string_view(partial_word).substr(1, partial_word.length()),
         original_word);
   }
 }
 
-const SearchTreeNode *SearchTreeNode::find(string_view search_term) const {
+const SearchTreeNode *SearchTreeNode::find(std::string_view search_term) const {
   if (search_term.empty()) {
     return this;
   }
@@ -26,8 +24,8 @@ const SearchTreeNode *SearchTreeNode::find(string_view search_term) const {
   return nullptr;
 }
 
-forward_list<const string *> SearchTreeNode::words() const {
-  forward_list<const string *> results(words_);
+std::forward_list<const std::string *> SearchTreeNode::words() const {
+  std::forward_list<const std::string *> results(words_);
   for (const auto &child : children_) {
     results.merge(child.second.words());
   }
@@ -35,17 +33,17 @@ forward_list<const string *> SearchTreeNode::words() const {
   return results;
 };
 
-SearchTree::SearchTree(const vector<string> &word_list) {
+SearchTree::SearchTree(const std::vector<std::string> &word_list) {
   for (const auto &word : word_list) {
-    insert(string_view(word), &word);
+    insert(std::string_view(word), &word);
   }
 }
 
-TreeFinder::TreeFinder(const vector<string> &word_list)
+TreeFinder::TreeFinder(const std::vector<string> &word_list)
     : search_tree_(word_list) {}
 
-forward_list<const string *>
-TreeFinder::find_prefix(string_view search_term) const {
+std::forward_list<const std::string *>
+TreeFinder::find_prefix(std::string_view search_term) const {
   const auto *result_node = search_tree_.find(search_term);
   if (result_node == nullptr) {
     return {};

vector_search_cli/main.cpp

@@ -1,7 +1,6 @@
 #include "grouped_finder.h"
 #include "linear_finder.h"
 #include "parallel_finder.h"
-#include "sorted_linear_finder.h"
 #include "timer.h"
 #include "tree_finder.h"
 #include "word_list_generator.h"
@@ -11,11 +10,11 @@
 
 using std::string, std::string_view, std::vector, std::cout, std::endl;
 
-vector<string> generate_word_list(size_t size_factor = 1) {
-  cout << "\ngenerating word list (" << size_factor << "x)" << endl;
+vector<string> generate_word_list() {
+  cout << "\ngenerating word list" << endl;
 
   Timer generator_timer;
-  auto word_list = WordListGenerator::generate(size_factor);
+  auto word_list = WordListGenerator::generate(5);
   generator_timer.stop();
 
   cout << "word list generator took " << generator_timer << endl;
@@ -35,31 +34,59 @@ void test_finder_search(Finder &finder, std::string_view name,
        << " element(s) long" << endl;
 }
 
-template <typename FINDER>
-void test_finder(const vector<string> &word_list,
-                 std::string_view finder_name) {
-  cout << "\nrunning " << finder_name << endl;
+void test_finder(Finder &finder, std::string_view name) {
+  for (const auto &search_term : {"A", "AB", "ABC", "ABCD"}) {
+    test_finder_search(finder, name, search_term);
+  }
+}
+
+void test_linear_finder(const vector<string> &word_list) {
+  cout << "\nrunning linear finder" << endl;
+
+  LinearFinder linear_finder(word_list);
+
+  test_finder(linear_finder, "linear finder");
+}
+
+void test_parallel_finder(const vector<string> &word_list) {
+  cout << "\nrunning parallel finder" << endl;
+
+  ParallelFinder parallel_finder(word_list);
+
+  test_finder(parallel_finder, "parallel finder");
+}
+
+void test_tree_finder(const vector<string> &word_list) {
+  cout << "\nrunning tree finder" << endl;
 
   Timer constructor_timer;
-  FINDER finder(word_list);
+  TreeFinder tree_finder(word_list);
   constructor_timer.stop();
-  cout << finder_name << " constructor took " << constructor_timer << endl;
+  cout << "tree finder constructor took " << constructor_timer << endl;
 
-  for (const auto &search_term : {"A", "AB", "ABC", "ABCD"}) {
-    test_finder_search(finder, finder_name, search_term);
-  }
+  test_finder(tree_finder, "tree finder");
+}
+
+void test_grouped_finder(const vector<string> &word_list) {
+  cout << "\nrunning grouped finder" << endl;
+
+  Timer constructor_timer;
+  GroupedFinder grouped_finder(word_list);
+  constructor_timer.stop();
+  cout << "grouped finder constructor took " << constructor_timer << endl;
+
+  test_finder(grouped_finder, "grouped_finder");
 }
 
 int main(int argc, char *argv[]) {
   cout << "\n== VectorSearch ==" << endl;
 
-  auto word_list = generate_word_list(5);
+  auto word_list = generate_word_list();
 
-  test_finder<LinearFinder>(word_list, "linear finder");
-  test_finder<SortedLinearFinder>(word_list, "sorted linear finder");
-  test_finder<ParallelFinder>(word_list, "parallel finder");
-  test_finder<TreeFinder>(word_list, "tree finder");
-  test_finder<GroupedFinder>(word_list, "grouped finder");
+  test_linear_finder(word_list);
+  test_parallel_finder(word_list);
+  test_tree_finder(word_list);
+  test_grouped_finder(word_list);
 
   return EXIT_SUCCESS;
 }