mirror of
https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git
synced 2023-10-11 13:05:55 +08:00
276 lines
8.3 KiB
C++
276 lines
8.3 KiB
C++
/**
|
|
* @file
|
|
* @brief Implementation of the [Sublist Search Algorithm](https://www.geeksforgeeks.org/sublist-search-search-a-linked-list-in-another-list) algorithm.
|
|
* @details
|
|
* * Sublist search is used to detect a presence of one list in another list.
|
|
* * Suppose we have a single-node list (let's say the first list), and we want to ensure that the list is present
|
|
* in another list (let's say the second list), then we can perform the sublist search to find it.
|
|
*
|
|
* * For instance, the first list contains these elements: 23 -> 30 -> 41, and the second list contains these
|
|
* elements: 10 -> 15 -> 23 -> 30 -> 41 -> 49. At a glance, we see that the first list presents in the second list.
|
|
*
|
|
* ### Working
|
|
* * The sublist search algorithm works by comparing the first element of the first list with the
|
|
* first element of the second list.
|
|
* * If the two values don't match, it goes to the next element of the second list. It does this until the two values match.
|
|
*
|
|
* @author [Nitin Sharma](https://github.com/foo290)
|
|
*/
|
|
|
|
#include <iostream> // for IO operations
|
|
#include <vector> // For passing data as array
|
|
#include <cassert> // For assert
|
|
|
|
/**
|
|
* A Node structure representing single link Node in a linked list.
|
|
*/
|
|
struct Node {
|
|
int data;
|
|
Node *next;
|
|
};
|
|
|
|
/**
|
|
* @brief Main searching function
|
|
* @param sublist A linked list which is supposed to be searched in mainList.
|
|
* @param mainList A linked list in which sublist will be searched.
|
|
* @returns bool If the sublist is found, returns true, else false.
|
|
*/
|
|
bool sublistSearch(Node *sublist, Node *mainList) {
|
|
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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* @brief A simple function to print the linked list.
|
|
* @param start The head of the linked list
|
|
* @returns void
|
|
*/
|
|
void printLinkedList(Node *start) {
|
|
while (start != nullptr) {
|
|
std::cout << "->" << start->data;
|
|
start = start->next;
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
/**
|
|
* @brief Makes a dummy linked list for testing.
|
|
* @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<int> &data) {
|
|
Node *head = nullptr;
|
|
Node *tail = nullptr;
|
|
for (int i : data) {
|
|
Node *node = new Node;
|
|
node->data = i;
|
|
node->next = nullptr;
|
|
if (head == nullptr) {
|
|
head = node;
|
|
tail = node;
|
|
}
|
|
else {
|
|
tail->next = node;
|
|
tail = tail->next;
|
|
}
|
|
}
|
|
return head;
|
|
}
|
|
|
|
/**
|
|
* A class, encapsulating the necessary test cases.
|
|
*/
|
|
class TestCases {
|
|
private:
|
|
template<typename T>
|
|
void log(T msg) {
|
|
// It's just to avoid writing cout and endl
|
|
std::cout << "[TESTS] : ---> " << msg << std::endl;
|
|
}
|
|
|
|
public:
|
|
void runTests() {
|
|
log("Running Tests...");
|
|
|
|
testCase_1();
|
|
testCase_2();
|
|
testCase_3();
|
|
|
|
log("Test Cases over!");
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
void testCase_1() {
|
|
const bool expectedOutput = true;
|
|
|
|
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
|
|
log("This is test case 1 for sublist search Algorithm : ");
|
|
log("Description:");
|
|
log(" EDGE CASE : Only contains one element");
|
|
|
|
std::vector<int> sublistData = {6};
|
|
std::vector<int> mainlistData = {2, 5, 6, 7, 8};
|
|
|
|
Node *sublistLL = makeLinkedList(sublistData);
|
|
Node *mainlistLL = makeLinkedList(mainlistData);
|
|
|
|
bool exists = sublistSearch(sublistLL, mainlistLL);
|
|
|
|
log("Checking assert expression...");
|
|
assert(exists == expectedOutput);
|
|
log("Assertion check passed!");
|
|
|
|
log("[PASS] : TEST CASE 1 PASS!");
|
|
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
|
|
|
|
delete(sublistLL);
|
|
delete(mainlistLL);
|
|
|
|
}
|
|
|
|
void testCase_2() {
|
|
const bool expectedOutput = true;
|
|
|
|
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<int> sublistData(20);
|
|
std::vector<int> mainlistData(100);
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
// 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
|
|
sublistData[temp] = i + 1;
|
|
temp++;
|
|
}
|
|
|
|
Node *sublistLL = makeLinkedList(sublistData);
|
|
Node *mainlistLL = makeLinkedList(mainlistData);
|
|
|
|
bool exists = sublistSearch(sublistLL, mainlistLL);
|
|
|
|
log("Checking assert expression...");
|
|
assert(exists == expectedOutput);
|
|
log("Assertion check passed!");
|
|
|
|
log("[PASS] : TEST CASE 2 PASS!");
|
|
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
|
|
}
|
|
|
|
void testCase_3() {
|
|
const bool expectedOutput = false;
|
|
|
|
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<int> sublistData(20);
|
|
std::vector<int> mainlistData(50);
|
|
|
|
|
|
for (int i = 0; i < 50; i++) {
|
|
// Inserts 100 elements in main list
|
|
mainlistData.push_back(i + 1);
|
|
}
|
|
|
|
for (int i = 45; i < 65; i++) {
|
|
// Inserts 20 elements in sublist
|
|
sublistData.push_back(i + 1);
|
|
}
|
|
|
|
Node *sublistLL = makeLinkedList(sublistData);
|
|
Node *mainlistLL = makeLinkedList(mainlistData);
|
|
|
|
bool exists = sublistSearch(sublistLL, mainlistLL);
|
|
|
|
log("Checking assert expression...");
|
|
assert(exists == expectedOutput);
|
|
log("Assertion check passed!");
|
|
|
|
log("[PASS] : TEST CASE 3 PASS!");
|
|
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @brief A test function that runs various checks
|
|
* @returns void
|
|
*/
|
|
void test() {
|
|
TestCases tc;
|
|
tc.runTests();
|
|
}
|
|
|
|
/**
|
|
* @brief Main function
|
|
* @param argc commandline argument count (ignored)
|
|
* @param argv commandline array of arguments (ignored)
|
|
* @returns 0 on exit
|
|
*/
|
|
int main(int argc, char *argv[]) {
|
|
test(); // Executing various test cases first.
|
|
|
|
std::vector<int> mainlistData = {2, 5, 6, 7, 8};
|
|
std::vector<int> sublistData = {6, 8};
|
|
Node *mainlistLL = makeLinkedList(mainlistData);
|
|
Node *sublistLL = makeLinkedList(sublistData);
|
|
|
|
bool exists = sublistSearch(sublistLL, mainlistLL);
|
|
|
|
std::cout << "Sublist :" << std::endl;
|
|
printLinkedList(sublistLL);
|
|
|
|
std::cout << "Main list : " << std::endl;
|
|
printLinkedList(mainlistLL);
|
|
std::cout << std::endl;
|
|
|
|
if (exists){
|
|
std::cout << "[TRUE] - sublist found in main list";
|
|
}
|
|
else{
|
|
std::cout << "[FALSE] - sublist NOT found in main list";
|
|
}
|
|
return 0;
|
|
}
|