Given the linked list representation of a string, the task is to swap every subsequent pair of vowels in it to produce the resultant linked list.
Examples:
Input: List = g -> e -> e -> k -> s -> NULL
Output: g -> e -> e -> k -> s -> NULL
The only vowels are ‘e’ and ‘e’ which
will be swapped with each other.Input: List = a -> b -> c -> d -> e -> NULL
Output: e -> b -> c -> d -> a -> NULL
swap(a, e)
Approach:
- Use two pointers of linked list node type for storing the node with the first vowel and for traversing the linked list respectively.
- Start traversing the linked list till the end.
- If a vowel is encountered and the first pointer already contains a node with a vowel in its data part, then swap the contents of the current node and the first node and the set the first pointer to NULL.
- In case a vowel is encountered and the first pointer does not contain anything, set the first pointer to point to this node.
- In case the vowel is not encountered, continue the traversal.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <iostream> using namespace std;
// Structure to hold the data and // the address of next element struct node {
char data;
node* next;
}; // Utility function to add a new // node to the linked list node* add( char data)
{ node* newnode = new node;
newnode->data = data;
newnode->next = NULL;
return newnode;
} // Function to add the given character // in the string to the linked list node* addinll(node* head, char data)
{ // If the linked list is empty then add
// it to the head otherwise add
// the character to the end
if (head == NULL)
head = add(data);
else {
node* curr = head;
while (curr->next != NULL)
curr = curr->next;
curr->next = add(data);
}
return head;
} // Function to print the linked list void print(node* head)
{ node* curr = head;
while (curr != NULL) {
cout << curr->data << " -> " ;
curr = curr->next;
}
cout << "NULL" ;
} // Function that returns true if // the character is vowel bool isvowel( char data)
{ if (data == 'a' || data == 'e'
|| data == 'i' || data == 'o'
|| data == 'u' )
return true ;
if (data == 'A' || data == 'E'
|| data == 'I' || data == 'O'
|| data == 'U' )
return true ;
return false ;
} // Function to reverse the vowels in the linked list void reversevowels(node* head)
{ // The pointer named first holds the
// address of the node containing
// the first vowel
node* first = NULL;
// The pointer curr is used
// to point to head
node* curr = head;
// Traverse the linked list
while (curr != NULL) {
// If a vowel is encountered and first is
// set to NULL then update the first
// with the address of this node
if (isvowel(curr->data) and first == NULL)
first = curr;
// If a vowel is encountered and the first
// already contains the address of a vowel
// then swap the current and the first's data
else if (isvowel(curr->data) and first != NULL) {
swap(first->data, curr->data);
// Set the first pointer to NULL
first = NULL;
}
curr = curr->next;
}
} // Driver code int main()
{ string s = "geeks" ;
// Start with an empty linked list
node* head = NULL;
// Add the characters one by
// one to the linked list
for ( int i = 0; i < s.size(); i++)
head = addinll(head, s[i]);
// Reverse the vowels
// in the linked list
reversevowels(head);
// Print the linked list
// with reversed vowels
print(head);
return 0;
} |
Java
// Java implementation of the approach class GFG{
// Structure to hold the data and // the address of next element static class node
{ char data;
node next;
}; // Utility function to add a new // node to the linked list static node add( char data)
{ node newnode = new node();
newnode.data = data;
newnode.next = null ;
return newnode;
} // Function to add the given character // in the String to the linked list static node addinll(node head, char data)
{ // If the linked list is empty then add
// it to the head otherwise add
// the character to the end
if (head == null )
head = add(data);
else
{
node curr = head;
while (curr.next != null )
curr = curr.next;
curr.next = add(data);
}
return head;
} // Function to print the linked list static void print(node head)
{ node curr = head;
while (curr != null )
{
System.out.print(curr.data + " -> " );
curr = curr.next;
}
System.out.print( "NULL" );
} // Function that returns true if // the character is vowel static boolean isvowel( char data)
{ if (data == 'a' || data == 'e' ||
data == 'i' || data == 'o' ||
data == 'u' )
return true ;
if (data == 'A' || data == 'E' ||
data == 'I' || data == 'O' ||
data == 'U' )
return true ;
return false ;
} // Function to reverse the vowels in the linked list static void reversevowels(node head)
{ // The pointer named first holds the
// address of the node containing
// the first vowel
node first = null ;
// The pointer curr is used
// to point to head
node curr = head;
// Traverse the linked list
while (curr != null )
{
// If a vowel is encountered and first is
// set to null then update the first
// with the address of this node
if (isvowel(curr.data) && first == null )
first = curr;
// If a vowel is encountered and the first
// already contains the address of a vowel
// then swap the current and the first's data
else if (isvowel(curr.data) && first != null )
{
swap(first.data, curr.data);
// Set the first pointer to null
first = null ;
}
curr = curr.next;
}
} private static void swap( char data, char data2)
{ // Auto-generated method stub
char newdata = data;
data = data2;
data2 = newdata;
} // Driver code public static void main(String[] args)
{ String s = "geeks" ;
// Start with an empty linked list
node head = null ;
// Add the characters one by
// one to the linked list
for ( int i = 0 ; i < s.length(); i++)
head = addinll(head, s.charAt(i));
// Reverse the vowels
// in the linked list
reversevowels(head);
// Print the linked list
// with reversed vowels
print(head);
} } // This code is contributed by gauravrajput1 |
Python3
# Python3 implementation of the approach # Structure to hold the data and # the address of next element class newNode:
def __init__( self , data):
self .data = data
self . next = None
# Utility function to add a new # node to the linked list def add(data):
newnode = newNode(data)
return newnode
# Function to add the given character # in the string to the linked list def addinll(head, data):
# If the linked list is empty then add
# it to the head otherwise add
# the character to the end
if (head = = None ):
head = add(data)
else :
curr = head
while (curr. next ! = None ):
curr = curr. next
curr. next = add(data)
return head
# Function to print the linked list def print1(head):
curr = head
while (curr ! = None ):
print (curr.data,end = " -> " )
curr = curr. next
print ( "Null" )
# Function that returns true if # the character is vowel def isvowel(data):
if (data = = 'a' or data = = 'e' or
data = = 'i' or data = = 'o' or
data = = 'u' ):
return True
if (data = = 'A' or data = = 'E' or
data = = 'I' or data = = 'O' or
data = = 'U' ):
return True
return False
# Function to reverse the vowels in the # linked list def reversevowels(head):
# The pointer named first holds the
# address of the node containing
# the first vowel
first = None
# The pointer curr is used
# to point to head
curr = head
# Traverse the linked list
while (curr ! = None ):
# If a vowel is encountered and first is
# set to None then update the first
# with the address of this node
if (isvowel(curr.data) and first = = None ):
first = curr
# If a vowel is encountered and the first
# already contains the address of a vowel
# then swap the current and the first's data
elif (isvowel(curr.data) and first ! = None ):
temp = first.data
first.data = curr.data
curr.data = temp
# Set the first pointer to None
first = None
curr = curr. next
# Driver code if __name__ = = '__main__' :
s = "geeks"
# Start with an empty linked list
head = None
# Add the characters one by
# one to the linked list
for i in range ( len (s)):
head = addinll(head, s[i])
# Reverse the vowels
# in the linked list
reversevowels(head)
# Print the linked list
# with reversed vowels
print1(head)
# This code is contributed by SURENDRA_GANGWAR |
C#
// C# implementation of the approach using System;
class GFG{
// Structure to hold the data and // the address of next element public class node
{ public char data;
public node next;
}; // Utility function to add a new // node to the linked list static node add( char data)
{ node newnode = new node();
newnode.data = data;
newnode.next = null ;
return newnode;
} // Function to add the given // character in the String to // the linked list static node addinll(node head,
char data)
{ // If the linked list is
// empty then add it to the
// head otherwise add the
// character to the end
if (head == null )
head = add(data);
else
{
node curr = head;
while (curr.next != null )
curr = curr.next;
curr.next = add(data);
}
return head;
} // Function to print the linked list static void print(node head)
{ node curr = head;
while (curr != null )
{
Console.Write(curr.data + " -> " );
curr = curr.next;
}
Console.Write( "NULL" );
} // Function that returns true if // the character is vowel static bool isvowel( char data)
{ if (data == 'a' || data == 'e' ||
data == 'i' || data == 'o' ||
data == 'u' )
return true ;
if (data == 'A' || data == 'E' ||
data == 'I' || data == 'O' ||
data == 'U' )
return true ;
return false ;
} // Function to reverse the vowels // in the linked list static void reversevowels(node head)
{ // The pointer named first
// holds the address of the
// node containing the first vowel
node first = null ;
// The pointer curr is used
// to point to head
node curr = head;
// Traverse the linked list
while (curr != null )
{
// If a vowel is encountered and first is
// set to null then update the first
// with the address of this node
if (isvowel(curr.data) &&
first == null )
first = curr;
// If a vowel is encountered and
// the first already contains the
// address of a vowel then swap the
// current and the first's data
else if (isvowel(curr.data) &&
first != null )
{
swap(first.data, curr.data);
// Set the first pointer to null
first = null ;
}
curr = curr.next;
}
} private static void swap( char data,
char data2)
{ // Auto-generated method stub
char newdata = data;
data = data2;
data2 = newdata;
} // Driver code public static void Main(String[] args)
{ String s = "geeks" ;
// Start with an empty linked list
node head = null ;
// Add the characters one by
// one to the linked list
for ( int i = 0; i < s.Length; i++)
head = addinll(head, s[i]);
// Reverse the vowels
// in the linked list
reversevowels(head);
// Print the linked list
// with reversed vowels
print(head);
} } // This code contributed by gauravrajput1 |
Javascript
<script> // JavaScript implementation of the approach
// Structure to hold the data and
// the address of next element
class node {
constructor() {
this .data = 0;
this .next = null ;
}
}
// Utility function to add a new
// node to the linked list
function add(data) {
var newnode = new node();
newnode.data = data;
newnode.next = null ;
return newnode;
}
// Function to add the given
// character in the String to
// the linked list
function addinll(head, data) {
// If the linked list is
// empty then add it to the
// head otherwise add the
// character to the end
if (head == null ) head = add(data);
else {
var curr = head;
while (curr.next != null ) curr = curr.next;
curr.next = add(data);
}
return head;
}
// Function to print the linked list
function print(head) {
var curr = head;
while (curr != null ) {
document.write(curr.data + " -> " );
curr = curr.next;
}
document.write( "NULL" );
}
// Function that returns true if
// the character is vowel
function isvowel(data) {
if (
data == "a" ||
data == "e" ||
data == "i" ||
data == "o" ||
data == "u"
)
return true ;
if (
data == "A" ||
data == "E" ||
data == "I" ||
data == "O" ||
data == "U"
)
return true ;
return false ;
}
// Function to reverse the vowels
// in the linked list
function reversevowels(head) {
// The pointer named first
// holds the address of the
// node containing the first vowel
var first = null ;
// The pointer curr is used
// to point to head
var curr = head;
// Traverse the linked list
while (curr != null ) {
// If a vowel is encountered and first is
// set to null then update the first
// with the address of this node
if (isvowel(curr.data) && first == null ) first = curr;
// If a vowel is encountered and
// the first already contains the
// address of a vowel then swap the
// current and the first's data
else if (isvowel(curr.data) && first != null ) {
swap(first.data, curr.data);
// Set the first pointer to null
first = null ;
}
curr = curr.next;
}
}
function swap(data, data2) {
// Auto-generated method stub
var newdata = data;
data = data2;
data2 = newdata;
}
// Driver code
var s = "geeks" ;
// Start with an empty linked list
var head = null ;
// Add the characters one by
// one to the linked list
for ( var i = 0; i < s.length; i++) head = addinll(head, s[i]);
// Reverse the vowels
// in the linked list
reversevowels(head);
// Print the linked list
// with reversed vowels
print(head);
// This code is contributed by rdtank.
</script>
|
Output:
g -> e -> e -> k -> s -> NULL
Article Tags :
Recommended Articles