Find the Longest Common Prefix using Word-by-Word Matching in Java

Finding the longest prefix in all the strings in a given array is the goal of the famous string manipulation issue known as the Longest Common Prefix (LCP) problem. Word by Word Matching is among the simplest ways to work through this puzzle.

Problem Statement

Determine the longest common prefix shared by every string in an array of strings. The longest initial substring shared by all strings is called the common prefix. In case there isn't a shared prefix, provide an empty string " ".

 
Input: {"intelligent", "intellect", "interest", "internet"}
Output: "inte"
Input: {"blueberry", "bluebell", "blues"}
Output: "blue"   

Word-by-Word Matching Approach

The Word-by-Word Matching method involves starting with the first string as a candidate for the longest common prefix and then iteratively comparing this candidate with each subsequent string in the array. The prefix is shortened as needed to maintain a match with each string until the longest common prefix for the entire array is found.

Steps

Initialize the Prefix: Begin by assuming the entire first string is the longest common prefix.
Iterate Through the Array: Compare the current prefix with each string in the array.
Shorten the Prefix: Reduce the prefix till it matches the beginning of the string if it does not appear at the start of the string.
Terminate: If the prefix becomes empty at any point, return an empty string as no common prefix exists.

File Name: LongestCommonPrefix.java

 
public class LongestCommonPrefix {
    // Function to find the longest common prefix using word-by-word matching
    public static String findLongestCommonPrefix(String[] word) {
        if (word == null || word.length == 0) {
            return "";
        }
        // Start with the first word as the initial prefix
        String prefix = word[0];
        // Iterate over the rest of the words
        for (int i = 1; i < word.length; i++) {
            // Compare the current prefix with each word
            while (word[i].indexOf(prefix) != 0) {
                // Shorten the prefix
                prefix = prefix.substring(0, prefix.length() - 1);
                if (prefix.isEmpty()) {
                    return "";
                }
            }
        }
        return prefix;
    }
    // Main method to test the function
    public static void main(String[] args) {
        String[] words1 = {"intelligent", "intellect", "interest", "internet"};
        String[] words2 = {"blueberry", "bluebell", "blues"};
        String lcp1 = findLongestCommonPrefix(words1);
        String lcp2 = findLongestCommonPrefix(words2);
        System.out.println("Longest Common Prefix (words1): " + lcp1); // Output: "inte"
        System.out.println("Longest Common Prefix (words2): " + lcp2); // Output: "blue"
    }
}   

Output:

 
Longest Common Prefix (words1): inte
Longest Common Prefix (words2): blue

Explanation

The LCP of the first two strings is "intel". When compared with the next string "interest", it is reduced to "inte", which is common among all strings. The LCP of the first two strings is "blue", which remains unchanged when compared with the third string "blues".

Complexity

Time Complexity

The time complexity of the Word by Word Matching approach for finding the Longest Common Prefix can be analyzed as follows:

Worst-Case Scenario: In the worst scenario, all the strings in the array must be compared character by character by the algorithm. In the worst scenario, the method executes O(n * L) character comparisons if the initial string contains L characters and there are n strings altogether.

Thus, the time complexity is O(n * L), where:

n is the number of strings.
L is the length of the longest string.

Space Complexity

The space complexity of this approach is minimal. The only extra space used is for storing the prefix string, which at most requires space proportional to the length of the first string.

Thus, the space complexity is O(1), ignoring the space required for the input since it only uses a constant amount of extra space.

Conclusion

A simple and efficient way to determine which string in a group has the longest common prefix is to use the Word by Word Matching method. This method makes sure that the final prefix is the longest shared by all strings in the array by gradually reducing it to match the beginning of each string. Even while this method is straightforward to use, it might not be the most effective for massive datasets, where more sophisticated algorithms might be more appropriate.

Next TopicFind-the-longest-substring-consisting-of-vowels-using-binary-search-in-java

← prev next →