What Is KMP Algorithm in Data Structure?


Larry Thompson

The KMP algorithm, also known as the Knuth-Morris-Pratt algorithm, is a string matching algorithm used in computer science and data structures. It aims to efficiently find occurrences of a pattern within a larger text string.

Understanding the Problem

Before diving into the KMP algorithm, it’s important to understand the problem it aims to solve. Suppose we have a text string T and a pattern string P. Our goal is to determine if P exists within T and, if so, locate all occurrences of P within T.

The Naive Approach

A straightforward approach to solve this problem would be to use brute force. We can start from the first character of T and compare each character with the corresponding characters of P until we either find a mismatch or successfully match all characters of P. If we find a mismatch, we shift our starting position by one and repeat the process.

This naive approach works but can be highly inefficient for certain cases. For example, consider searching for “ABC” in the text string “ABABABABCD”. The naive approach would compare all characters at each step, resulting in redundant comparisons.

The KMP Algorithm

The KMP algorithm improves upon the naive approach by utilizing information about previous matches. It preprocesses the pattern string P to construct an auxiliary array called “lps” (longest proper prefix which is also suffix).

To construct this array, we iterate through each character of P and determine its longest proper prefix which is also a suffix up until that point. This information allows us to skip unnecessary comparisons during our search.


  • P = “ABCABC”
  • lps = [0, 0, 0, 1, 2, 3]

With the lps array in hand, we can now perform the KMP algorithm. We maintain two pointers: one for T (i) and one for P (j). We compare characters of T and P at their respective pointers and make decisions based on the values in the lps array.

Algorithm Steps:

  1. Initialize i = 0 and j = 0.
  2. While i is less than the length of T:
    • If T[i] equals P[j], increment both i and j.
    • If j equals the length of P, we have found a match. Reset j to lps[j-1] to continue searching for more matches starting from there.
    • If T[i] does not equal P[j], check if j is greater than zero.

      If so, reset j to lps[j-1]. Otherwise, increment i.

This process continues until either we exhaust all characters in T or find all occurrences of P within T.


The KMP algorithm provides an efficient solution to the string matching problem by utilizing the concept of longest proper prefix which is also a suffix. By preprocessing the pattern string and skipping unnecessary comparisons during runtime, it reduces redundant operations and improves overall performance.

Understanding algorithms like KMP helps us optimize our code and solve complex problems more efficiently. Incorporating such algorithms in our projects can significantly enhance their performance.

Discord Server - Web Server - Private Server - DNS Server - Object-Oriented Programming - Scripting - Data Types - Data Structures

Privacy Policy