# Algorithms_in_C++: search/sublist_search.cpp File Reference

Loading...
Searching...
No Matches
sublist_search.cpp File Reference

Implementation of the Sublist Search Algorithm More...

`#include <cassert>`
`#include <iostream>`
`#include <vector>`
Include dependency graph for sublist_search.cpp:

## Classes

struct | search::sublist_search::Node
| A Node structure representing a single link Node in a linked list. More...
class | TestCases
| class encapsulating the necessary test cases More...

## Namespaces

namespace | search
| for std::vector
namespace | sublist_search
| Functions for the Sublist Search implementation.

## Functions

void | search::sublist_search::printLinkedList (Node *start)
| A simple function to print the linked list. More...
Node * | search::sublist_search::makeLinkedList (const std::vector< uint64_t > &data)
| Give a vector of data, it adds each element of vector in the linked list and return the address of head pointer. More...
bool | search::sublist_search::sublistSearch (Node *sublist, Node *mainList)
| Main searching function. More...
static void | test ()
| Self-test implementations. More...
int | main (int argc, char *argv[])
| Main function. More...

## Detailed Description

Implementation of the Sublist Search Algorithm

### Algorithm

- 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

## Function Documentation

## main()

int main | ( | int | argc,
|  | char * | argv[]
| ) |  |

Main function.

Parameters

  argc | commandline argument count (ignored)
  argv | commandline array of arguments (ignored)

Returns
  0 on exit

< Main list in which sublist is to be searched

< Sublist to be searched

< Main list in which sublist is to be searched

< boolean to check if the sublist exists or not

{
test(); // run self-test implementations
std::vector<uint64_t> mainlistData = {
2, 5, 6, 7, 8}; ///< Main list in which sublist is to be searched
std::vector<uint64_t> sublistData = {6, 8}; ///< Sublist to be searched
search::sublist_search::Node *mainlistLL =
search::sublist_search::makeLinkedList(mainlistData);
search::sublist_search::Node *sublistLL =
search::sublist_search::makeLinkedList(
sublistData); ///< Main list in which sublist is to be
///< searched
bool exists = search::sublist_search::sublistSearch(
sublistLL,
mainlistLL); ///< boolean to check if the sublist exists or not
std::cout << "Sublist: " << std::endl;
search::sublist_search::printLinkedList(sublistLL);
std::cout << "Main list: " << std::endl;
search::sublist_search::printLinkedList(mainlistLL);
std::cout << std::endl;
if (exists) {
std::cout << "[TRUE] - sublist found in main list\n";
} else {
std::cout << "[FALSE] - sublist NOT found in main list\n";
}
return 0;
}
std::cout
std::endl
T endl(T... args)
search::sublist_search::Node
A Node structure representing a single link Node in a linked list.
Definition: sublist_search.cpp:47
search::sublist_search::sublistSearch
bool sublistSearch(Node *sublist, Node *mainList)
Main searching function.
Definition: sublist_search.cpp:100
search::sublist_search::makeLinkedList
Node * makeLinkedList(const std::vector< uint64_t > &data)
Give a vector of data, it adds each element of vector in the linked list and return the address of he...
Definition: sublist_search.cpp:73
test
static void test()
Self-test implementations.
Definition: sublist_search.cpp:328
search::sublist_search::printLinkedList
void printLinkedList(Node *start)
A simple function to print the linked list.
Definition: sublist_search.cpp:57
std::vector
dynamic_programming::word_break::exists
bool exists(const std::string &str, const std::unordered_set< std::string > &strSet)
Function that checks if the string passed in param is present in the the unordered_set passed.
Definition: word_break.cpp:60
Here is the call graph for this function:

## makeLinkedList()

Node * search::sublist_search::makeLinkedList | ( | const std::vector< uint64_t > & | data | ) |

Give a vector of data, it adds each element of vector in the linked list and return the address of head pointer.

Parameters

  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.

This is used in test cases for rapidly creating linked list with 100+ elements, instead of hard-coding 100 elements in test cases.

{
/// This is used in test cases for rapidly creating linked list with 100+
/// elements, instead of hard-coding 100 elements in test cases.
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;
}
data
int data[MAX]
test data
Definition: hash_search.cpp:24
Node
Definition: linkedlist_implentation_usingarray.cpp:14
node
Definition: avltree.cpp:13
Here is the call graph for this function:

## printLinkedList()

void search::sublist_search::printLinkedList | ( | Node * | start | ) |

A simple function to print the linked list.

Parameters

  start | The head of the linked list

Returns
  void

{
while (start != nullptr) {
std::cout << "->" << start->data;
start = start->next;
}
std::cout << std::endl;
}
Here is the call graph for this function:

## sublistSearch()

bool search::sublist_search::sublistSearch | ( | Node * | sublist,
|  | Node * | mainList
| ) |  |

Main searching function.

Parameters

  sublist | A linked list which is supposed to be searched in mainList.
  mainList | A linked list in which sublist will be searched.

Returns
  true if the sublist is found
  false if the sublist is NOT found

Initialize target pointer to the head node of sublist.

Initialize main pointer to the current node of main list.

If the data of target node and main node is equal then move to the next node of both lists.

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.

set the target pointer again to stating point of target list.

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

{
if (sublist == nullptr || mainList == nullptr) {
return false;
}
/// 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;
}
Here is the call graph for this function:

## test()

static void test | ( |  | ) |

static

Self-test implementations.

Returns
  void

{
TestCases tc;
tc.runTests();
}
TestCases
class encapsulating the necessary test cases
Definition: inorder_successor_of_bst.cpp:225
TestCases::runTests
void runTests()
Executes test cases.
Definition: inorder_successor_of_bst.cpp:243
Here is the call graph for this function: