docs updated for one line docs

search/sublist_search.cpp

@@ -39,51 +39,54 @@ namespace search {
  * Search](https://www.geeksforgeeks.org/sublist-search-search-a-linked-list-in-another-list)
  * implementation
  */
-namespace sublist_search {
+    namespace sublist_search {
 /**
  * @brief A Node structure representing a single link Node in a linked list
  */
-struct Node {
+        struct Node {
-    uint32_t data = 0;  ///< the key/value of the node
+            uint32_t data = 0;  ///< the key/value of the node
-    Node *next{};       ///< pointer to the next node
+            Node *next{};       ///< pointer to the next node
-};
+        };
 
 /**
  * @brief A simple function to print the linked list
  * @param start The head of the linked list
  * @returns void
  */
-void printLinkedList(Node *start) {
+        void printLinkedList(Node *start) {
-    while (start != nullptr) {
+            while (start != nullptr) {
-        std::cout << "->" << start->data;
+                std::cout << "->" << start->data;
-        start = start->next;
+                start = start->next;
-    }
+            }
-    std::cout << std::endl;
+            std::cout << std::endl;
-}
+        }
 
 /**
- * @brief Makes a dummy linked list for testing.
+ * @brief Give a vector of data,
+ * it adds each element of vector in the linked list and return the address of head pointer.
  * @param data A vector of "int" containing the data that is supposed to be
  * stored in nodes of linked list.
  * @returns Node* A head pointer to the linked list.
  */
-Node *makeLinkedList(const std::vector<uint64_t> &data) {
+        Node *makeLinkedList(const std::vector<uint64_t> &data) {
-    Node *head = nullptr;
+            /// This is used in test cases for rapidly creating linked list with 100+ elements, instead of hard-coding
-    Node *tail = nullptr;
+            /// 100 elements in test cases.
-    for (int i : data) {
+            Node *head = nullptr;
-        Node *node = new Node;
+            Node *tail = nullptr;
-        node->data = i;
+            for (int i : data) {
-        node->next = nullptr;
+                Node *node = new Node;
-        if (head == nullptr) {
+                node->data = i;
-            head = node;
+                node->next = nullptr;
-            tail = node;
+                if (head == nullptr) {
-        } else {
+                    head = node;
-            tail->next = node;
+                    tail = node;
-            tail = tail->next;
+                } else {
+                    tail->next = node;
+                    tail = tail->next;
+                }
+            }
+            return head;
         }
-    }
-    return head;
-}
 
 /**
  * @brief Main searching function
@@ -92,57 +95,59 @@ Node *makeLinkedList(const std::vector<uint64_t> &data) {
  * @returns true if the sublist is found
  * @returns false if the sublist is NOT found
  */
-bool sublistSearch(Node *sublist, Node *mainList) {
+        bool sublistSearch(Node *sublist, Node *mainList) {
-    if (sublist == nullptr || mainList == nullptr) {
+            if (sublist == nullptr || mainList == nullptr) {
-        return false;
-    }
-
-    Node *target_ptr = sublist;
-
-    while (mainList != nullptr) {
-        Node *main_ptr = mainList;  // Initialize main pointer to the current
-        // node of main list.
-
-        while (target_ptr != nullptr) {
-            if (main_ptr == nullptr) {
                 return false;
-
-            } else if (main_ptr->data == target_ptr->data) {
-                // If the data of target node and main node is equal then move
-                // to the next node of both lists.
-                target_ptr = target_ptr->next;
-                main_ptr = main_ptr->next;
-
-            } else {
-                break;
             }
+
+            /// Initialize target pointer to the head node of sublist.
+            Node *target_ptr = sublist;
+
+            while (mainList != nullptr) {
+                /// Initialize main pointer to the current node of main list.
+                Node *main_ptr = mainList;
+
+                while (target_ptr != nullptr) {
+                    if (main_ptr == nullptr) {
+                        return false;
+
+                    } else if (main_ptr->data == target_ptr->data) {
+                        /// If the data of target node and main node is equal then move
+                        /// to the next node of both lists.
+                        target_ptr = target_ptr->next;
+                        main_ptr = main_ptr->next;
+
+                    } else {
+                        break;
+                    }
+                }
+
+                if (target_ptr == nullptr) {
+                    /// Is target pointer becomes null that means the target list is been
+                    /// traversed without returning false. Which means the sublist has
+                    /// been found and return ture.
+                    return true;
+                }
+
+                /// set the target pointer again to stating point of target list.
+                target_ptr = sublist;
+
+                /// set the main pointer to the next element of the main list and repeat the algo.
+                mainList = mainList->next;
+            }
+
+            /// If the main list is exhausted, means sublist does not found, return false
+            return false;
         }
 
-        if (target_ptr == nullptr) {
+    }  // namespace sublist_search
-            // Is target pointer becomes null that means the target list is been
-            // traversed without returning false. Which means the sublist has
-            // been found and return ture.
-            return true;
-        }
-
-        target_ptr = sublist;  // set the target pointer again to stating point
-        // of target list.
-        mainList = mainList->next;  // set the main pointer to the next element
-        // of the main list and repeat the algo.
-    }
-
-    // If the main list is exhausted, means sublist does not found, return false
-    return false;
-}
-
-}  // namespace sublist_search
 }  // namespace search
 
 /**
  * @brief class encapsulating the necessary test cases
  */
 class TestCases {
- private:
+private:
     /**
      * @brief A function to print given message on console.
      * @tparam T Type of the given message.
@@ -154,7 +159,7 @@ class TestCases {
         std::cout << "[TESTS] : ---> " << msg << std::endl;
     }
 
- public:
+public:
     /**
      * @brief Executes test cases
      * @returns void
@@ -175,7 +180,7 @@ class TestCases {
      * @returns void
      * */
     void testCase_1() {
-        const bool expectedOutput = true;
+        const bool expectedOutput = true;  /// Expected output of this test
 
         log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
             "~");
@@ -183,16 +188,16 @@ class TestCases {
         log("Description:");
         log("   EDGE CASE : Only contains one element");
 
-        std::vector<uint64_t> sublistData = {6};
+        std::vector<uint64_t> sublistData = {6};  /// Data to make linked list which will be the sublist
-        std::vector<uint64_t> mainlistData = {2, 5, 6, 7, 8};
+        std::vector<uint64_t> mainlistData = {2, 5, 6, 7, 8};  /// Data to make linked list which will be the main list
 
         search::sublist_search::Node *sublistLL =
-            search::sublist_search::makeLinkedList(sublistData);
+                search::sublist_search::makeLinkedList(sublistData);  /// Sublist to be searched
         search::sublist_search::Node *mainlistLL =
-            search::sublist_search::makeLinkedList(mainlistData);
+                search::sublist_search::makeLinkedList(mainlistData);  /// Main list in which sublist is to be searched
 
         bool exists = search::sublist_search::sublistSearch(
-            sublistLL, mainlistLL);  // boolean, if sublist exist or not
+                sublistLL, mainlistLL);  /// boolean, if sublist exist or not
 
         log("Checking assert expression...");
         assert(exists == expectedOutput);
@@ -212,44 +217,42 @@ class TestCases {
      * @returns void
      * */
     void testCase_2() {
-        const bool expectedOutput = true;
+        const bool expectedOutput = true;  /// Expected output of this test
 
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
-            "~");
         log("This is test case 2 for sublist search Algorithm : ");
         log("Description:");
         log("   contains main list of 100 elements and sublist of 20");
 
-        std::vector<uint64_t> sublistData(20);
+        std::vector<uint64_t> sublistData(20);  /// Data to make linked list which will be the sublist
-        std::vector<uint64_t> mainlistData(100);
+        std::vector<uint64_t> mainlistData(100); /// Main list in which sublist is to be searched
 
         for (int i = 0; i < 100; i++) {
-            // Inserts 100 elements in main list
+            /// Inserts 100 elements in main list
             mainlistData[i] = i + 1;
         }
 
         int temp = 0;
         for (int i = 45; i < 65; i++) {
-            // Inserts 20 elements in sublist
+            /// Inserts 20 elements in sublist
             sublistData[temp] = i + 1;
             temp++;
         }
 
         search::sublist_search::Node *sublistLL =
-            search::sublist_search::makeLinkedList(sublistData);
+                search::sublist_search::makeLinkedList(sublistData);  /// Sublist to be searched
         search::sublist_search::Node *mainlistLL =
-            search::sublist_search::makeLinkedList(mainlistData);
+                search::sublist_search::makeLinkedList(mainlistData);  /// Main list in which sublist is to be searched
 
         bool exists = search::sublist_search::sublistSearch(
-            sublistLL, mainlistLL);  // boolean, if sublist exist or not
+                sublistLL, mainlistLL);  // boolean, if sublist exist or not
 
         log("Checking assert expression...");
         assert(exists == expectedOutput);
         log("Assertion check passed!");
 
         log("[PASS] : TEST CASE 2 PASS!");
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
-            "~");
     }
 
     /**
@@ -258,42 +261,40 @@ class TestCases {
      * @returns void
      * */
     void testCase_3() {
-        const bool expectedOutput = false;
+        const bool expectedOutput = false;  /// Expected output of this test
 
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
-            "~");
         log("This is test case 3 for sublist search Algorithm : ");
         log("Description:");
         log("   contains main list of 50 elements and sublist of 20");
 
-        std::vector<uint64_t> sublistData(20);
+        std::vector<uint64_t> sublistData(20);  /// Sublist to be searched
-        std::vector<uint64_t> mainlistData(50);
+        std::vector<uint64_t> mainlistData(50);  /// Main list in which sublist is to be searched
 
         for (int i = 0; i < 50; i++) {
-            // Inserts 100 elements in main list
+            /// Inserts 100 elements in main list
             mainlistData.push_back(i + 1);
         }
 
         for (int i = 45; i < 65; i++) {
-            // Inserts 20 elements in sublist
+            /// Inserts 20 elements in sublist
             sublistData.push_back(i + 1);
         }
 
         search::sublist_search::Node *sublistLL =
-            search::sublist_search::makeLinkedList(sublistData);
+                search::sublist_search::makeLinkedList(sublistData);  /// Sublist to be searched
         search::sublist_search::Node *mainlistLL =
-            search::sublist_search::makeLinkedList(mainlistData);
+                search::sublist_search::makeLinkedList(mainlistData);  /// Main list in which sublist is to be searched
 
         bool exists = search::sublist_search::sublistSearch(
-            sublistLL, mainlistLL);  // boolean, if sublist exist or not
+                sublistLL, mainlistLL);  /// boolean, if sublist exist or not
 
         log("Checking assert expression...");
         assert(exists == expectedOutput);
         log("Assertion check passed!");
 
         log("[PASS] : TEST CASE 3 PASS!");
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
-            "~");
     }
 };
 
@@ -313,17 +314,18 @@ static void test() {
  * @returns 0 on exit
  */
 int main(int argc, char *argv[]) {
-    test();  // run self-test implementations
+    test();  /// run self-test implementations
 
     std::vector<uint64_t> mainlistData = {2, 5, 6, 7, 8};
     std::vector<uint64_t> sublistData = {6, 8};
+
     search::sublist_search::Node *mainlistLL =
-        search::sublist_search::makeLinkedList(mainlistData);
+            search::sublist_search::makeLinkedList(mainlistData);
     search::sublist_search::Node *sublistLL =
-        search::sublist_search::makeLinkedList(sublistData);
+            search::sublist_search::makeLinkedList(sublistData);
 
     bool exists = search::sublist_search::sublistSearch(
-        sublistLL, mainlistLL);  // boolean, if sublist exist or not
+            sublistLL, mainlistLL);  // boolean, if sublist exist or not
 
     std::cout << "Sublist :" << std::endl;
     search::sublist_search::printLinkedList(sublistLL);