# Longest Common Prefix using Linked List

Given a set of strings, find the longest common prefix.

**Examples:**

Input : {“geeksforgeeks”, “geeks”, “geek”, “geezer”} Output : "gee" Input : {"apple", "ape", "april"} Output : "ap"

**Previous Approaches:** Word by Word Matching, Character by Character Matching, Divide and Conquer, Binary Search, Using Trie Data Structure

Below is an algorithm to solve above problem using **Linked List**.

- Create a linked list using the characters of the first string as the data in the linked list.
- Then one by one using all the remaining strings, iterate over the linked list deleting all the nodes after the point where the string gets exhausted or linked list gets exhausted or the characters do not match.
- The remaining data in linked list is the required longest common prefix.

Below is the implementation in C++

`// C++ Program to find the longest common prefix ` `// in an array of strings ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Structure for a node in the linked list ` `struct` `Node { ` ` ` `char` `data; ` ` ` `Node* next; ` `}; ` ` ` `// Function to print the data in the linked list ` `// Remaining nodes represent the longest common prefix ` `void` `printLongestCommonPrefix(Node* head) ` `{ ` ` ` `// If the linked list is empty there is ` ` ` `// no common prefix ` ` ` `if` `(head == NULL) { ` ` ` `cout << ` `"There is no common prefix\n"` `; ` ` ` `return` `; ` ` ` `} ` ` ` ` ` `// Printing the longest common prefix ` ` ` `cout << ` `"The longest common prefix is "` `; ` ` ` `while` `(head != NULL) { ` ` ` `cout << head->data; ` ` ` `head = head->next; ` ` ` `} ` `} ` ` ` `// Function that creates a linked list of characters ` `// for the first word in the array of strings ` `void` `Initialise(Node** head, string str) ` `{ ` ` ` `// We calculate the length of the string ` ` ` `// as we will insert from the last to the ` ` ` `// first character ` ` ` `int` `l = str.length(); ` ` ` ` ` `// Inserting all the nodes with the characters ` ` ` `// using insert at the beginning technique ` ` ` `for` `(` `int` `i = l - 1; i >= 0; i--) { ` ` ` `Node* temp = ` `new` `Node; ` ` ` `temp->data = str[i]; ` ` ` `temp->next = *head; ` ` ` `*head = temp; ` ` ` `} ` ` ` ` ` `// Since we have passed the address of the ` ` ` `// head node it is not required to return ` ` ` `// anything ` `} ` ` ` `// Function to delete all the nodes ` `// from the unmatched node till the end of the ` `// linked list ` `void` `deleteNodes(Node* head) ` `{ ` ` ` `// temp is used to facilitate the deletion of nodes ` ` ` `Node* current = head; ` ` ` `Node* next; ` ` ` `while` `(current != NULL) { ` ` ` `next = current->next; ` ` ` `free` `(current); ` ` ` `current = next; ` ` ` `} ` `} ` ` ` `// Function that compares the character of the string with ` `// the nodes of the linked list and deletes all nodes after ` `// the characters that do not match ` `void` `longestCommonPrefix(Node** head, string str) ` `{ ` ` ` `int` `i = 0; ` ` ` ` ` `// Use the pointer to the previous node to ` ` ` `// delete the link between the unmatched node ` ` ` `// and its prev node ` ` ` `Node* temp = *head; ` ` ` `Node* prev = *head; ` ` ` `while` `(temp != NULL) { ` ` ` ` ` `// If the current string finishes or if the ` ` ` `// the characters in the linked list do not match ` ` ` `// with the character at the corresponding position ` ` ` `// delete all the nodes after that. ` ` ` `if` `(str[i] == ` `'\0'` `|| temp->data != str[i]) { ` ` ` ` ` `// If the first node does not match then there ` ` ` `// is no common prefix ` ` ` `if` `(temp == *head) { ` ` ` `free` `(temp); ` ` ` `*head = NULL; ` ` ` `} ` ` ` ` ` `// Delete all the nodes starting from the ` ` ` `// unmatched node ` ` ` `else` `{ ` ` ` `prev->next = NULL; ` ` ` `deleteNodes(temp); ` ` ` `} ` ` ` `break` `; ` ` ` `} ` ` ` ` ` `// If the character matches, move to next ` ` ` `// node and store the address of the current ` ` ` `// node in prev ` ` ` `prev = temp; ` ` ` `temp = temp->next; ` ` ` `i++; ` ` ` `} ` `} ` ` ` `int` `main() ` `{ ` ` ` `string arr[] = { ` `"geeksforgeeks"` `, ` `"geeks"` `, ` `"geek"` `, ` `"geezer"` `, ` ` ` `"geekathon"` `}; ` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `struct` `Node* head = NULL; ` ` ` ` ` `// A linked list is created with all the characters ` ` ` `// of the first string ` ` ` `Initialise(&head, arr[0]); ` ` ` ` ` `// Process all the remaining strings to find the ` ` ` `// longest common prefix ` ` ` `for` `(` `int` `i = 1; i < n; i++) ` ` ` `longestCommonPrefix(&head, arr[i]); ` ` ` ` ` `printLongestCommonPrefix(head); ` `} ` |

*chevron_right*

*filter_none*

**Output:**

The longest common prefix is gee

## Recommended Posts:

- Longest Common Prefix using Sorting
- Longest Common Prefix Matching | Set-6
- Longest Common Prefix using Trie
- Longest Common Prefix using Binary Search
- Find minimum shift for longest common prefix
- Longest Common Prefix using Divide and Conquer Algorithm
- Find the longest common prefix between two strings after performing swaps on second string
- Longest Common Prefix using Word by Word Matching
- Longest Common Prefix using Character by Character Matching
- Longest common suffix of two linked lists
- Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some Common nodes
- Length of longest palindrome list in a linked list using O(1) extra space
- Find the common nodes in two singly linked list
- Longest increasing sublist in a linked list
- Longest prefix which is also suffix

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.