named namespace

hashing/quadratic_probing_hash_table.cpp

@@ -10,8 +10,14 @@
 #include <iostream>
 #include <vector>
 
-namespace {  // keep the code local to this file by assigning them to an unnamed
-
+/**
+ * @addtogroup Open Addressing
+ * @{
+ * @namespace quadratic_probing
+ * @brief An implementation of hash table using [quadratic
+ * probing](https://en.wikipedia.org/wiki/Quadratic_probing) algorithm.
+ */
+namespace quadratic_probing {
 // fwd declarations
 using Entry = struct Entry;
 bool putProber(const Entry& entry, int key);
@@ -26,19 +32,27 @@ int tomb = -1;
 int size;
 bool rehashing;
 
-// Node that holds key
+/** Node that holds key
+ */
 struct Entry {
-    explicit Entry(int key = notPresent) : key(key) {}
-    int key;
+    explicit Entry(int key = notPresent) : key(key) {}  ///< constructor
+    int key;                                            ///< key value
 };
 
-// Hash a key
+/** Hash a key
+ * @param key key value to hash
+ * @returns hash of the key
+ */
 size_t hashFxn(int key) {
     std::hash<int> hash;
     return hash(key);
 }
 
-// Performs quadratic probing to resolve collisions
+/** Performs quadratic probing to resolve collisions
+ * @param key key value to search/probe
+ * @param searching `true` if only searching, `false1 if assigning
+ * @returns value of `notPresent`.
+ */
 int quadraticProbe(int key, bool searching) {
     int hash = static_cast<int>(hashFxn(key));
     int i = 0;
@@ -83,7 +97,12 @@ int quadraticProbe(int key, bool searching) {
     return notPresent;
 }
 
-// Finds empty spot
+/** Finds empty spot
+ * @param entry Instance of table entry
+ * @param key key value to search/probe
+ * @returns `true` if key is present
+ * @returns `false` if key is absent
+ */
 bool putProber(const Entry& entry, int key) {
     if (entry.key == notPresent || entry.key == tomb) {
         return true;
@@ -91,7 +110,12 @@ bool putProber(const Entry& entry, int key) {
     return false;
 }
 
-// Looks for a matching key
+/** Looks for a matching key
+ * @param entry Instance of table entry
+ * @param key key value to search/probe
+ * @returns `true` if key matches the entry
+ * @returns `false` if key does not match the entry
+ */
 bool searchingProber(const Entry& entry, int key) {
     if (entry.key == key) {
         return true;
@@ -99,7 +123,11 @@ bool searchingProber(const Entry& entry, int key) {
     return false;
 }
 
-// Helper
+/** Get the entry instance corresponding to a key
+ * @param key key value to search/probe
+ * @returns if present, the entry instance
+ * @returns if not present, a new instance
+ */
 Entry find(int key) {
     int index = quadraticProbe(key, true);
     if (index == notPresent) {
@@ -108,7 +136,9 @@ Entry find(int key) {
     return table[index];
 }
 
-// Displays the table
+/** Displays the table
+ * @returns None
+ */
 void display() {
     for (int i = 0; i < totalSize; i++) {
         if (table[i].key == notPresent) {
@@ -124,7 +154,9 @@ void display() {
     std::cout << std::endl;
 }
 
-// Rehashes the table into a bigger table
+/** Rehashes the table into a bigger table
+ * @returns none
+ */
 void rehash() {
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
@@ -144,7 +176,9 @@ void rehash() {
     std::cout << "Table was rehashed, new size is: " << totalSize << std::endl;
 }
 
-// Checks for load factor here
+/** Checks for load factor here
+ * @param key  key value to hash and add to table
+ */
 void add(int key) {
     int index = quadraticProbe(key, false);
     table[index].key = key;
@@ -154,7 +188,9 @@ void add(int key) {
     }
 }
 
-// Removes key. Leaves tombstone upon removal.
+/** Removes key. Leaves tombstone upon removal.
+ * @param key  key value to hash and remove from table
+ */
 void remove(int key) {
     int index = quadraticProbe(key, true);
     if (index == notPresent) {
@@ -165,7 +201,9 @@ void remove(int key) {
     size--;
 }
 
-// Information about the adding process
+/** Information about the adding process
+ * @param key  key value to hash and add to table
+ */
 void addInfo(int key) {
     std::cout << "Initial table: ";
     display();
@@ -178,7 +216,9 @@ void addInfo(int key) {
     display();
 }
 
-// Information about removal process
+/** Information about removal process
+ * @param key  key value to hash and remove from table
+ */
 void removalInfo(int key) {
     std::cout << "Initial table: ";
     display();
@@ -190,9 +230,19 @@ void removalInfo(int key) {
     std::cout << "New table: ";
     display();
 }
-}  // namespace
 
-// I/O
+}  // namespace quadratic_probing
+/**
+ * @}
+ */
+
+using quadratic_probing::Entry;
+using quadratic_probing::table;
+using quadratic_probing::totalSize;
+
+/** Main function
+ * @returns None
+ */
 int main() {
     int cmd = 0, hash = 0, key = 0;
     std::cout << "Enter the initial size of Hash Table. = ";
@@ -214,18 +264,20 @@ int main() {
             case 1:
                 std::cout << "Enter key to add = ";
                 std::cin >> key;
-                addInfo(key);
+                quadratic_probing::addInfo(key);
                 break;
             case 2:
                 std::cout << "Enter key to remove = ";
                 std::cin >> key;
-                removalInfo(key);
+                quadratic_probing::removalInfo(key);
                 break;
             case 3: {
                 std::cout << "Enter key to search = ";
                 std::cin >> key;
-                Entry entry = table[quadraticProbe(key, true)];
-                if (entry.key == notPresent) {
+                quadratic_probing::Entry entry =
+                    quadratic_probing::table[quadratic_probing::quadraticProbe(
+                        key, true)];
+                if (entry.key == quadratic_probing::notPresent) {
                     std::cout << "Key not present";
                 }
                 break;
@@ -233,10 +285,11 @@ int main() {
             case 4:
                 std::cout << "Enter element to generate hash = ";
                 std::cin >> key;
-                std::cout << "Hash of " << key << " is = " << hashFxn(key);
+                std::cout << "Hash of " << key
+                          << " is = " << quadratic_probing::hashFxn(key);
                 break;
             case 5:
-                display();
+                quadratic_probing::display();
                 break;
             default:
                 loop = false;