Longest Common Prefix in DSA Java - Execution Trace

Concept Flow - Longest Common Prefix

Start with first string as prefix

↓

For each next string in array

↓

Compare prefix with current string

↓

Shorten prefix until it matches start of current string

↓

If prefix empty, return ""

↓

Next string

↓

All strings processed

↓

Return prefix

Start with the first string as the prefix. Compare it with each next string, shortening the prefix until it matches the start of that string. If prefix becomes empty, return empty string. Otherwise, after all strings, return the prefix.

Execution Sample

DSA Java

String longestCommonPrefix(String[] strs) {
  if (strs.length == 0) return "";
  String prefix = strs[0];
  for (int i = 1; i < strs.length; i++) {
    while (!strs[i].startsWith(prefix)) {
      prefix = prefix.substring(0, prefix.length() - 1);
      if (prefix.isEmpty()) return "";
    }
  }
  return prefix;
}

Finds the longest common prefix string among an array of strings by iteratively shortening the prefix.

Execution Table

Step	Operation	Current String	Prefix Before	Prefix After	Visual State
1	Initialize prefix	N/A	N/A	flower	[flower]
2	Compare prefix with 'flow'	flow	flower	flow	[flow]
3	Compare prefix with 'flight'	flight	flow	fl	[fl]
4	All strings processed	N/A	fl	fl	[fl]

💡 All strings processed, prefix 'fl' is longest common prefix

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
prefix	flower	flow	fl	fl

Key Moments - 3 Insights

Why do we shorten the prefix inside the while loop?

Because the current prefix does not match the start of the current string, so we remove the last character until it matches or becomes empty, as shown in steps 2 and 3 of the execution_table.

What happens if the prefix becomes empty?

If prefix becomes empty, it means no common prefix exists, so the function returns an empty string. This is implied in the while loop condition and exit logic.

Why do we start prefix with the first string?

Starting with the first string ensures the prefix is initially the longest possible. Then we shorten it based on other strings, as shown in step 1 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the prefix after comparing with the second string 'flow'?

A fl

B flower

C flow

D flight

💡 Hint

Check the 'Prefix After' column at Step 2 in the execution_table.

At which step does the prefix become 'fl'?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Prefix After' column in the execution_table for each step.

If the input array was ['dog', 'racecar', 'car'], what would happen to the prefix during execution?

A Prefix remains 'dog'

B Prefix becomes empty string

C Prefix shortens to 'd'

D Prefix becomes 'car'

💡 Hint

Think about the while loop shortening prefix until it matches start of each string.

Concept Snapshot

Longest Common Prefix:
- Start prefix as first string
- For each next string, shorten prefix until it matches start
- If prefix empty, return ""
- Else return prefix after all strings
- Uses startsWith and substring methods

Full Transcript

This concept finds the longest common prefix among an array of strings. It starts by taking the first string as the initial prefix. Then, it compares this prefix with each subsequent string. If the prefix does not match the start of the current string, it shortens the prefix by removing the last character repeatedly until it matches or becomes empty. If the prefix becomes empty, it means there is no common prefix, so the function returns an empty string. Otherwise, after processing all strings, it returns the prefix. The execution table shows how the prefix changes step-by-step with example strings 'flower', 'flow', and 'flight'.

Practice

1. What does the Longest Common Prefix (LCP) of a list of strings represent?

easy

A. The longest substring found anywhere in all strings

B. The longest ending substring common to all strings

C. The longest starting substring common to all strings

D. The shortest substring common to any two strings

Solution

1. Step 1: Understand the prefix concept

   A prefix is a substring starting at the beginning of a string.

2. Step 2: Define longest common prefix

   The longest common prefix is the longest substring starting at the beginning that all strings share.

3. Final Answer:

   The longest starting substring common to all strings -> Option C

4. Quick Check:

   Prefix means start of string = longest common start [OK]

Hint: Longest common prefix starts at string beginnings [OK]

Common Mistakes:

• Confusing prefix with substring anywhere
• Thinking it is the longest suffix
• Mixing prefix with shortest substring

2. Which of the following Java method signatures is correct for a function that finds the longest common prefix of an array of strings named strs?

easy

A. public String longestCommonPrefix(String[] strs)

B. public void longestCommonPrefix(String[] strs)

C. public int longestCommonPrefix(String[] strs)

D. public String longestCommonPrefix(List<String> strs)

Solution

1. Step 1: Identify return type for prefix

   The longest common prefix is a string, so return type must be String.

2. Step 2: Check parameter type

   The input is an array of strings, so parameter type is String[].

3. Final Answer:

   public String longestCommonPrefix(String[] strs) -> Option A

4. Quick Check:

   Return String, input String[] = public String longestCommonPrefix(String[] strs) [OK]

Hint: Return type matches prefix type; input is String array [OK]

Common Mistakes:

• Using void return type instead of String
• Returning int instead of String
• Using List<String> instead of String[]

3. What is the output of the following Java code?

public class Test {
  public static String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) return "";
    String prefix = strs[0];
    for (int i = 1; i < strs.length; i++) {
      while (!strs[i].startsWith(prefix)) {
        prefix = prefix.substring(0, prefix.length() - 1);
        if (prefix.isEmpty()) return "";
      }
    }
    return prefix;
  }
  public static void main(String[] args) {
    String[] input = {"flower", "flow", "flight"};
    System.out.println(longestCommonPrefix(input));
  }
}

medium

A. "flow"

B. "fl"

C. "f"

D. ""

Solution

1. Step 1: Initialize prefix and check each string

   Start with prefix = "flower". Check "flow": "flow" starts with "flower"? No, shorten prefix to "flowe", then "flow", which matches.

2. Step 2: Check next string "flight"

   "flight" starts with "flow"? No, shorten prefix to "flo", then "fl", which matches.

3. Final Answer:

   "fl" -> Option B

4. Quick Check:

   Common start of all strings = "fl" [OK]

Hint: Shorten prefix until all strings start with it [OK]

Common Mistakes:

• Returning first string without checking others
• Not shortening prefix correctly
• Returning empty string too early

4. Identify the error in the following Java method for finding the longest common prefix:

public String longestCommonPrefix(String[] strs) {
  if (strs.length == 0) return null;
  String prefix = strs[0];
  for (int i = 1; i <= strs.length; i++) {
    while (!strs[i].startsWith(prefix)) {
      prefix = prefix.substring(0, prefix.length() - 1);
      if (prefix.isEmpty()) return "";
    }
  }
  return prefix;
}

medium

A. The substring method is used incorrectly

B. The method should return null instead of empty string when no prefix

C. The prefix should be initialized as an empty string

D. The loop condition should be i < strs.length, not i <= strs.length

Solution

1. Step 1: Check loop bounds

   The for loop uses i <= strs.length, which causes ArrayIndexOutOfBoundsException because valid indices are 0 to strs.length - 1.

2. Step 2: Correct loop condition

   Change to i < strs.length to avoid accessing invalid index.

3. Final Answer:

   The loop condition should be i < strs.length, not i <= strs.length -> Option D

4. Quick Check:

   Array indices go from 0 to length-1 [OK]

Hint: Loop index must be less than array length [OK]

Common Mistakes:

• Using i <= length causing runtime error
• Returning null instead of empty string
• Incorrect substring usage

5. Given the array String[] words = {"interview", "interrupt", "integrate", "integral"};, which of the following modifications to the longest common prefix algorithm will correctly find the prefix "int" even if some strings are empty or null?

hard

A. Add checks to skip null or empty strings before comparing prefixes

B. Return the first string immediately if any string is null or empty

C. Ignore the first string and start prefix from the second string

D. Use the longest string as the initial prefix instead of the first string

Solution

1. Step 1: Understand problem with null or empty strings

   Null or empty strings cause errors or incorrect prefix results if not handled.

2. Step 2: Modify algorithm to skip or handle null/empty

   Check each string before comparing; skip or handle null/empty to avoid errors and find correct prefix.

3. Final Answer:

   Add checks to skip null or empty strings before comparing prefixes -> Option A

4. Quick Check:

   Handle null/empty strings safely to find correct prefix [OK]

Hint: Always check for null or empty strings before prefix checks [OK]

Common Mistakes:

• Not handling null causing exceptions
• Returning first string without checks
• Starting prefix from wrong string