Daa Tut 6 Sudhanshu Raut: Pseudo Code For KMP Algorithm

DAA TUT 6
sudhanshu raut
iib2020040
1.
Knuth-Morris and Pratt introduce a linear time algorithm for the string matching
problem. A matching time of O (n) is achieved by avoiding comparison with an
element of 'S' that have previously been involved in comparison with some element
of the pattern 'p' to be matched. i.e., backtracking on the string 'S' never occurs
Components of KMP Algorithm:
Pseudo Code for KMP Algorithm

table[0] = 0
i = 0, j = 1
while (j < n) { // n is the length of pattern p
if (p[i] == p[j]) {
table[j] = i + 1; i++;
j++;
} else {
if (i != 0) {
i = table[i - 1];
// Do not increment j here
} else { table[j] = 0;
j++;
}
}
Time Complexity: O(m +
n) Space Complexity:
O(m + n)
2.
// C++ program for implementation of KMP pattern searching
// algorithm
#include <bits/stdc++.h>
void computeLPSArray(char* pat, int M, int* lps);
// Prints occurrences of txt[] in pat[]

void KMPSearch(char* pat, char* txt)
{
int M = strlen(pat);
int N = strlen(txt);
// create lps[] that will hold the longest prefix suffix

// values for pattern
int lps[M];
// Preprocess the pattern (calculate lps[] array)

computeLPSArray(pat, M, lps);
int i = 0; // index for

txt[] int j = 0; // index
for pat[] while (i < N) {
if (pat[j] == txt[i]) {
j++;
i++;
}
if (j == M) {
printf("Found pattern at index %d ", i - j);
j = lps[j - 1];
}
// mismatch after j matches

else if (i < N && pat[j] != txt[i]) {
// Do not match lps[0..lps[j-1]] characters,
// they will match
anyway if (j != 0)
j = lps[j - 1];
else i = i + 1;
}
}
}
// Fills lps[] for given patttern pat[0..M-1]

void computeLPSArray(char* pat, int M, int* lps)
{
// length of the previous longest prefix suffix
int len = 0;
lps[0] = 0; // lps[0] is always 0
// the loop calculates lps[i] for i = 1 to M -1

int i = 1;
while (i < M) {
if (pat[i] == pat[len]) { len++;
lps[i] = len;
i++;
}
else // (pat[i] != pat[len])
{
// This is tricky. Consider the example.
// AAACAAAA and i = 7. The idea is similar
// to search step. if (len
!= 0) {
len = lps[len - 1];
// Also, note that we do not increment

// i here
}
else // if (len == 0)
{
lps[i] = 0; i++;
}
}
}
}
// Driver program to test above function int main()

{
char S= ”ABBAAABBCABCABBABBA”;
char pat[] = "ABBA";
KMPSearch(pat, S); return 0;
}
3.
A Trie is an advanced data structure that is sometimes also known as prefix

tree or digital tree. It is a tree that stores the data in an ordered and efficient
way. We generally use trie's to store strings. Each node of a trie can have as
many as 26 references (pointers).
Insert of a node in the Trie
The first operation is to insert a new node into the trie. Before we start the
implementation, it is important to understand some points:
Every letter of the input key (word) is inserted as an individual in the Trie_node.
Note that children point to the next level of Trie nodes.
The key character array acts as an index of children.
If the present node already has a reference to the present letter, set the present
node to that referenced node. Otherwise, create a new node, set the letter to be
equal to the present letter, and even start the present node with this new node.
public class Data_Trie { private

Node_Trie root; public
Data_Trie(){
this.root = new Node_Trie();
}
public void insert(String word){ Node_Trie
current = root; int length =
word.length();
for (int x = 0; x < length; x++){ char L =
word.charAt(x);
Node_Trie node = current.getNode().get(L); if (node
== null){
node = new Node_Trie ();
current.getNode().put(L, node);
}
current = node;
}
current.setWord(true);
}
}
Searching a node in Trie
The second operation is to search for a node in a Trie. The searching operation is
similar to the insertion operation. The search operation is used to search a key in the
trie. The implementation of the searching operation is shown below.
class Search_Trie {
private Node_Trie Prefix_Search(String W) { Node_Trie

node = R;
for (int x = 0; x < W.length(); x++) { char
curLetter = W.charAt(x);
if (node.containsKey(curLetter))
{
node = node.get(curLetter);
}
else {
return null;
}
}
return node;
}
public boolean search(String W) { Node_Trie node

= Prefix_Search(W); return node != null &&
node.isEnd();
}
}
4.
In Trie structure, we have a field to store end of word marker, we call it isLeaf in
below implementation. To count words, we need to simply traverse the Trie and
count all nodes where isLeaf is set.
// C++ implementation to count words in a trie #include

<bits/stdc++.h>
using namespace std;
#define ARRAY_SIZE(a) sizeof(a)/sizeof(a[0])
// Alphabet size (# of symbols) #define

ALPHABET_SIZE (26)
// Converts key current character into index

// use only 'a' through 'z' and lower case #define
CHAR_TO_INDEX(c) ((int)c - (int)'a')
// Trie node struct

TrieNode
{
struct TrieNode *children[ALPHABET_SIZE];
// isLeaf is true if the node represents

// end of a word bool
isLeaf;
};
// Returns new trie node (initialized to NULLs) struct

TrieNode *getNode(void)
{
struct TrieNode *pNode = new TrieNode;
pNode->isLeaf = false;
for (int i = 0; i < ALPHABET_SIZE;
i++) pNode->children[i] = NULL;
return pNode;
}
// If not present, inserts key into trie

// If the key is prefix of trie node, just
// marks leaf node
void insert(struct TrieNode *root, const char *key)
{
int length = strlen(key);
struct TrieNode *pCrawl = root;
for (int level = 0; level < length; level++)

{
int index = CHAR_TO_INDEX(key[level]);
if (!pCrawl->children[index])
pCrawl->children[index] = getNode();
pCrawl = pCrawl->children[index];
}
// mark last node as

leaf pCrawl->isLeaf =
true;
}
// Function to count number of words

int wordCount(struct TrieNode *root)
{
int result = 0;
// Leaf denotes end of a word

if (root -> isLeaf)
result++;
for (int i = 0; i < ALPHABET_SIZE; i++)

if (root -> children[i])
result += wordCount(root -> children[i]);
return result;
}
// Driver
int main()
{
// Input keys (use only 'a' through 'z'
// and lower case)
char keys[][8] = {"the", "a", "there", "answer",
"any", "by", "bye", "their"};
struct TrieNode *root = getNode();
// Construct Trie
for (int i = 0; i < ARRAY_SIZE(keys); i++)
insert(root, keys[i]);
cout << wordCount(root); return 0;
5.
// C++ program to sort an array of strings

// using Trie
#include <bits/stdc++.h>
using namespace std;
const int MAX_CHAR = 26;
struct Trie {
// index is set when node is a leaf

// node, otherwise -1;
int index;
Trie* child[MAX_CHAR];
/*to make new trie*/

Trie()
{
for (int i = 0; i < MAX_CHAR; i++)
child[i] = NULL;
index = -1;
}
};
/* function to insert in trie */

void insert(Trie* root, string str, int index)
{
Trie* node = root;
for (int i = 0; i < str.size(); i++) {
/* taking ascii value to find index of

child node */
char ind = str[i] - 'a';
/* making new path if not already */

if (!node->child[ind])
node->child[ind] = new Trie();
// go to next node
node = node->child[ind];
}
// Mark leaf (end of word) and store

// index of word in
arr[] node->index =
index;
}
/* function for preorder traversal */

bool preorder(Trie* node, string arr[])
{
if (node == NULL)
return
false;
for (int i = 0; i < MAX_CHAR; i++) {

if (node->child[i] != NULL) {
/* if leaf node then print key*/

if (node->child[i]->index != -1)
cout << arr[node->child[i]->index] << endl;
preorder(node->child[i], arr);
}
}
}
void printSorted(string arr[], int n)

{
Trie* root = new Trie();
// insert all keys of dictionary into trie

for (int i = 0; i < n; i++)
6JBGBJ6
insert(root, arr[i], i);
// print keys in lexicographic order

preorder(root, arr);
}
// Driver code
int main()
{
string arr[] = { "abc", "xy", "bcd" };
int n = sizeof(arr) / sizeof(arr[0]);
printSorted(arr, n);
return 0;
}
6.

Daa Tut 6 Sudhanshu Raut: Pseudo Code For KMP Algorithm

Uploaded by

Copyright:

Available Formats

Daa Tut 6 Sudhanshu Raut: Pseudo Code For KMP Algorithm

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Daa Tut 6 Sudhanshu Raut: Pseudo Code For KMP Algorithm

Uploaded by

Copyright:

Available Formats

DAA TUT 6

Components of KMP Algorithm:

Pseudo Code for KMP Algorithm

Time Complexity: O(m +

void computeLPSArray(char* pat, int M, int* lps);

// Prints occurrences of txt[] in pat[]

// create lps[] that will hold the longest prefix suffix

// Preprocess the pattern (calculate lps[] array)

int i = 0; // index for

// mismatch after j matches

// Fills lps[] for given patttern pat[0..M-1]

lps[0] = 0; // lps[0] is always 0

// the loop calculates lps[i] for i = 1 to M -1

// Also, note that we do not increment

// Driver program to test above function int main()

A Trie is an advanced data structure that is sometimes also known as prefix

Insert of a node in the Trie

The key character array acts as an index of children.

public class Data_Trie { private

Searching a node in Trie

private Node_Trie Prefix_Search(String W) { Node_Trie

public boolean search(String W) { Node_Trie node

// C++ implementation to count words in a trie #include

#define ARRAY_SIZE(a) sizeof(a)/sizeof(a[0])

// Alphabet size (# of symbols) #define

// Converts key current character into index

// Trie node struct

// isLeaf is true if the node represents

// Returns new trie node (initialized to NULLs) struct

// If not present, inserts key into trie

struct TrieNode *pCrawl = root;

for (int level = 0; level < length; level++)

// mark last node as

// Function to count number of words

// Leaf denotes end of a word

for (int i = 0; i < ALPHABET_SIZE; i++)

struct TrieNode *root = getNode();

// C++ program to sort an array of strings

const int MAX_CHAR = 26;

// index is set when node is a leaf

/*to make new trie*/

/* function to insert in trie */

for (int i = 0; i < str.size(); i++) {

/* taking ascii value to find index of

/* making new path if not already */

// Mark leaf (end of word) and store

/* function for preorder traversal */

for (int i = 0; i < MAX_CHAR; i++) {

/* if leaf node then print key*/

void printSorted(string arr[], int n)

// insert all keys of dictionary into trie

insert(root, arr[i], i);

// print keys in lexicographic order

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

/to make new trie/