Arrange consonants and vowels nodes in a linked list

• Difficulty Level : Medium
• Last Updated : 25 Apr, 2022

Given a singly linked list, we need to arrange the consonants and vowel nodes of it in such a way that all the vowel nodes come before the consonants while maintaining the order of their arrival.
Examples:

```Input : a -> b -> c -> e -> d ->
o -> x -> i
Output : a -> e -> o -> i -> b ->
c -> d -> x```

Solution :
The idea is to keep a marker of the latest vowel we found while traversing the list. If we find another vowel, we take it out of the chain and put it after the existing latest vowel. Example: For linked list:

`a -> b -> c -> e -> d -> o -> x -> i`

say our latestVowel reference references the ‘a’ node, and that we currently reached the ‘e’ node. We do:

`a -> e -> b -> c -> d -> o -> x -> i`

So what was after the ‘a’ node is now after the ‘e’ node after deleting it, and linking ‘a’ directly to ‘e’.
To properly remove and add links, it’s best to use the node before the one you are checking. So if you have a curr, you will check curr->next node to see if it’s a vowel or not. If it is, we need to add it after the latestVowel node, and then it’s easy to remove it from the chain by assigning its next to curr’s next. Also, if a list only contains consonants, we simply return head.

C

 `/* C program to arrange consonants and ` `vowels nodes in a linked list */` `#include ` `#include ` `#include ` `/* A linked list node */` `struct` `Node ` `{ ` `    ``char` `data; ` `    ``struct` `Node *next; ` `}; ` ` `  `/* Function to add new node to the List */` `struct` `Node *newNode(``char` `key) ` `{ ` `    ``struct` `Node *temp = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node)); ` `    ``temp->data = key; ` `    ``temp->next = NULL; ` `    ``return` `temp; ` `} ` ` `  `// utility function to print linked list ` `void` `printlist(``struct` `Node *head) ` `{ ` `    ``if` `(! head) ` `    ``{ ` `        ``printf``(``"Empty list \n"``); ` `        ``return``; ` `    ``} ` `    ``while` `(head != NULL) ` `    ``{ ` `        ``printf``(``"%c"``,head->data); ` `        ``if` `(head->next) ` `        ``printf``(``"->"``); ` `        ``head = head->next; ` `    ``} ` `    ``printf``(``"\n"``); ` `} ` ` `  `// utility function for checking vowel ` `bool` `isVowel(``char` `x) ` `{ ` `    ``return` `(x == ``'a'` `|| x == ``'e'` `|| x == ``'i'` `|| ` `            ``x == ``'o'` `|| x == ``'u'``); ` `} ` ` `  `/* function to arrange consonants and ` `vowels nodes */` `struct` `Node *arrange(``struct` `Node *head) ` `{ ` `    ``struct` `Node *newHead = head; ` ` `  `    ``// for keep track of vowel ` `struct`     `Node *latestVowel; ` ` `  `    ``struct` `Node *curr = head; ` ` `  `    ``// list is empty ` `    ``if` `(head == NULL) ` `        ``return` `NULL; ` ` `  `    ``// We need to discover the first vowel ` `    ``// in the list. It is going to be the ` `    ``// returned head, and also the initial ` `    ``// latestVowel. ` `    ``if` `(isVowel(head->data)) ` ` `  `        ``// first element is a vowel. It will ` `        ``// also be the new head and the initial ` `        ``// latestVowel; ` `        ``latestVowel = head; ` ` `  `    ``else` `    ``{ ` ` `  `        ``// First element is not a vowel. Iterate ` `        ``// through the list until we find a vowel. ` `        ``// Note that curr points to the element ` `        ``// *before* the element with the vowel. ` `        ``while` `(curr->next != NULL && ` `            ``!isVowel(curr->next->data)) ` `            ``curr = curr->next; ` ` `  ` `  `        ``// This is an edge case where there are ` `        ``// only consonants in the list. ` `        ``if` `(curr->next == NULL) ` `            ``return` `head; ` ` `  `        ``// Set the initial latestVowel and the ` `        ``// new head to the vowel item that we found. ` `        ``// Relink the chain of consonants after ` `        ``// that vowel item: ` `        ``// old_head_consonant->consonant1->consonant2-> ` `        ``// vowel->rest_of_list becomes ` `        ``// vowel->old_head_consonant->consonant1-> ` `        ``// consonant2->rest_of_list ` `        ``latestVowel = newHead = curr->next; ` `        ``curr->next = curr->next->next; ` `        ``latestVowel->next = head; ` `    ``} ` ` `  `    ``// Now traverse the list. Curr is always the item ` `    ``// *before* the one we are checking, so that we ` `    ``// can use it to re-link. ` `    ``while` `(curr != NULL && curr->next != NULL) ` `    ``{ ` `        ``if` `(isVowel(curr->next->data)) ` `        ``{ ` `            ``// The next discovered item is a vowel ` `            ``if` `(curr == latestVowel) ` `            ``{ ` `                ``// If it comes directly after the ` `                ``// previous vowel, we don't need to ` `                ``// move items around, just mark the ` `                ``// new latestVowel and advance curr. ` `                ``latestVowel = curr = curr->next; ` `            ``} ` `            ``else` `            ``{ ` ` `  `                ``// But if it comes after an intervening ` `                ``// chain of consonants, we need to chain ` `                ``// the newly discovered vowel right after ` `                ``// the old vowel. Curr is not changed as ` `                ``// after the re-linking it will have a ` `                ``// new next, that has not been checked yet, ` `                ``// and we always keep curr at one before ` `                ``// the next to check. ` `                ``struct` `Node *temp = latestVowel->next; ` ` `  `                ``// Chain in new vowel ` `                ``latestVowel->next = curr->next; ` ` `  `                ``// Advance latestVowel ` `                ``latestVowel = latestVowel->next; ` ` `  `                ``// Remove found vowel from previous place ` `                ``curr->next = curr->next->next; ` ` `  `                ``// Re-link chain of consonants after latestVowel ` `                ``latestVowel->next = temp; ` `            ``} ` `        ``} ` `        ``else` `        ``{ ` ` `  `            ``// No vowel in the next element, advance curr. ` `            ``curr = curr->next; ` `        ``} ` `    ``} ` `    ``return` `newHead; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``struct` `Node *head = newNode(``'a'``); ` `    ``head->next = newNode(``'b'``); ` `    ``head->next->next = newNode(``'c'``); ` `    ``head->next->next->next = newNode(``'e'``); ` `    ``head->next->next->next->next = newNode(``'d'``); ` `    ``head->next->next->next->next->next = newNode(``'o'``); ` `    ``head->next->next->next->next->next->next = newNode(``'x'``); ` `    ``head->next->next->next->next->next->next->next = newNode(``'i'``); ` ` `  `    ``printf``(``"Linked list before :\n"``); ` `    ``printlist(head); ` ` `  `    ``head = arrange(head); ` ` `  `    ``printf``(``"Linked list after :\n"``); ` `    ``printlist(head); ` ` `  `    ``return` `0; ` `} `

C++

 `/* C++ program to arrange consonants and ` `   ``vowels nodes in a linked list */` `#include ` `using` `namespace` `std; ` ` `  `/* A linked list node */` `struct` `Node ` `{ ` `    ``char` `data; ` `    ``struct` `Node *next; ` `}; ` ` `  `/* Function to add new node to the List */` `Node *newNode(``char` `key) ` `{ ` `    ``Node *temp = ``new` `Node; ` `    ``temp->data = key; ` `    ``temp->next = NULL; ` `    ``return` `temp; ` `} ` ` `  `// utility function to print linked list ` `void` `printlist(Node *head) ` `{ ` `    ``if` `(! head) ` `    ``{ ` `        ``cout << ``"Empty List\n"``; ` `        ``return``; ` `    ``} ` `    ``while` `(head != NULL) ` `    ``{ ` `        ``cout << head->data << ``" "``; ` `        ``if` `(head->next) ` `           ``cout << ``"-> "``; ` `        ``head = head->next; ` `    ``} ` `    ``cout << endl; ` `} ` ` `  `// utility function for checking vowel ` `bool` `isVowel(``char` `x) ` `{ ` `    ``return` `(x == ``'a'` `|| x == ``'e'` `|| x == ``'i'` `|| ` `            ``x == ``'o'` `|| x == ``'u'``); ` `} ` ` `  `/* function to arrange consonants and ` `   ``vowels nodes */` `Node *arrange(Node *head) ` `{ ` `    ``Node *newHead = head; ` ` `  `    ``// for keep track of vowel ` `    ``Node *latestVowel; ` ` `  `    ``Node *curr = head; ` ` `  `    ``// list is empty ` `    ``if` `(head == NULL) ` `        ``return` `NULL; ` ` `  `    ``// We need to discover the first vowel ` `    ``// in the list. It is going to be the ` `    ``// returned head, and also the initial ` `    ``// latestVowel. ` `    ``if` `(isVowel(head->data)) ` ` `  `        ``// first element is a vowel. It will ` `        ``// also be the new head and the initial ` `        ``// latestVowel; ` `        ``latestVowel = head; ` ` `  `    ``else` `    ``{ ` ` `  `        ``// First element is not a vowel. Iterate ` `        ``// through the list until we find a vowel. ` `        ``// Note that curr points to the element ` `        ``// *before* the element with the vowel. ` `        ``while` `(curr->next != NULL && ` `               ``!isVowel(curr->next->data)) ` `            ``curr = curr->next; ` ` `  ` `  `        ``// This is an edge case where there are ` `        ``// only consonants in the list. ` `        ``if` `(curr->next == NULL) ` `            ``return` `head; ` ` `  `        ``// Set the initial latestVowel and the ` `        ``// new head to the vowel item that we found. ` `        ``// Relink the chain of consonants after ` `        ``// that vowel item: ` `        ``// old_head_consonant->consonant1->consonant2-> ` `        ``// vowel->rest_of_list becomes ` `        ``// vowel->old_head_consonant->consonant1-> ` `        ``// consonant2->rest_of_list ` `        ``latestVowel = newHead = curr->next; ` `        ``curr->next = curr->next->next; ` `        ``latestVowel->next = head; ` `    ``} ` ` `  `    ``// Now traverse the list. Curr is always the item ` `    ``// *before* the one we are checking, so that we ` `    ``// can use it to re-link. ` `    ``while` `(curr != NULL && curr->next != NULL) ` `    ``{ ` `        ``if` `(isVowel(curr->next->data)) ` `        ``{ ` `            ``// The next discovered item is a vowel ` `            ``if` `(curr == latestVowel) ` `            ``{ ` `                ``// If it comes directly after the ` `                ``// previous vowel, we don't need to ` `                ``// move items around, just mark the ` `                ``// new latestVowel and advance curr. ` `                ``latestVowel = curr = curr->next; ` `            ``} ` `            ``else` `            ``{ ` ` `  `                ``// But if it comes after an intervening ` `                ``// chain of consonants, we need to chain ` `                ``// the newly discovered vowel right after ` `                ``// the old vowel. Curr is not changed as ` `                ``// after the re-linking it will have a ` `                ``// new next, that has not been checked yet, ` `                ``// and we always keep curr at one before ` `                ``// the next to check. ` `                ``Node *temp = latestVowel->next; ` ` `  `                ``// Chain in new vowel ` `                ``latestVowel->next = curr->next; ` ` `  `                ``// Advance latestVowel ` `                ``latestVowel = latestVowel->next; ` ` `  `                ``// Remove found vowel from previous place ` `                ``curr->next = curr->next->next; ` ` `  `                ``// Re-link chain of consonants after latestVowel ` `                ``latestVowel->next = temp; ` `            ``} ` `        ``} ` `        ``else` `        ``{ ` ` `  `            ``// No vowel in the next element, advance curr. ` `            ``curr = curr->next; ` `        ``} ` `    ``} ` `    ``return` `newHead; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``Node *head = newNode(``'a'``); ` `    ``head->next = newNode(``'b'``); ` `    ``head->next->next = newNode(``'c'``); ` `    ``head->next->next->next = newNode(``'e'``); ` `    ``head->next->next->next->next = newNode(``'d'``); ` `    ``head->next->next->next->next->next = newNode(``'o'``); ` `    ``head->next->next->next->next->next->next = newNode(``'x'``); ` `    ``head->next->next->next->next->next->next->next = newNode(``'i'``); ` ` `  `    ``printf``(``"Linked list before :\n"``); ` `    ``printlist(head); ` ` `  `    ``head = arrange(head); ` ` `  `    ``printf``(``"Linked list after :\n"``); ` `    ``printlist(head); ` ` `  `    ``return` `0; ` `} `

Java

 `/* Java program to arrange consonants and  ` `vowels nodes in a linked list */` `class` `GfG ` `{  ` ` `  `/* A linked list node */` `static` `class` `Node  ` `{  ` `    ``char` `data;  ` `    ``Node next;  ` `} ` ` `  `/* Function to add new node to the List */` `static` `Node newNode(``char` `key)  ` `{  ` `    ``Node temp = ``new` `Node();  ` `    ``temp.data = key;  ` `    ``temp.next = ``null``;  ` `    ``return` `temp;  ` `}  ` ` `  `// utility function to print linked list  ` `static` `void` `printlist(Node head)  ` `{  ` `    ``if` `(head == ``null``)  ` `    ``{  ` `        ``System.out.println(``"Empty List"``);  ` `        ``return``;  ` `    ``}  ` `    ``while` `(head != ``null``)  ` `    ``{  ` `        ``System.out.print(head.data +``" "``);  ` `        ``if` `(head.next != ``null``)  ` `        ``System.out.print(``"-> "``);  ` `        ``head = head.next;  ` `    ``}  ` `    ``System.out.println(); ` `}  ` ` `  `// utility function for checking vowel  ` `static` `boolean` `isVowel(``char` `x)  ` `{  ` `    ``return` `(x == ``'a'` `|| x == ``'e'` `|| x == ``'i'` `||  ` `            ``x == ``'o'` `|| x == ``'u'``);  ` `}  ` ` `  `/* function to arrange consonants and  ` `vowels nodes */` `static` `Node arrange(Node head)  ` `{  ` `    ``Node newHead = head;  ` ` `  `    ``// for keep track of vowel  ` `    ``Node latestVowel;  ` ` `  `    ``Node curr = head;  ` ` `  `    ``// list is empty  ` `    ``if` `(head == ``null``)  ` `        ``return` `null``;  ` ` `  `    ``// We need to discover the first vowel  ` `    ``// in the list. It is going to be the  ` `    ``// returned head, and also the initial  ` `    ``// latestVowel.  ` `    ``if` `(isVowel(head.data) == ``true``)  ` ` `  `        ``// first element is a vowel. It will  ` `        ``// also be the new head and the initial  ` `        ``// latestVowel;  ` `        ``latestVowel = head;  ` ` `  `    ``else` `    ``{  ` ` `  `        ``// First element is not a vowel. Iterate  ` `        ``// through the list until we find a vowel.  ` `        ``// Note that curr points to the element  ` `        ``// *before* the element with the vowel.  ` `        ``while` `(curr.next != ``null` `&&  ` `            ``!isVowel(curr.next.data))  ` `            ``curr = curr.next;  ` ` `  ` `  `        ``// This is an edge case where there are  ` `        ``// only consonants in the list.  ` `        ``if` `(curr.next == ``null``)  ` `            ``return` `head;  ` ` `  `        ``// Set the initial latestVowel and the  ` `        ``// new head to the vowel item that we found.  ` `        ``// Relink the chain of consonants after  ` `        ``// that vowel item:  ` `        ``// old_head_consonant->consonant1->consonant2->  ` `        ``// vowel->rest_of_list becomes  ` `        ``// vowel->old_head_consonant->consonant1->  ` `        ``// consonant2->rest_of_list  ` `        ``latestVowel = newHead = curr.next;  ` `        ``curr.next = curr.next.next;  ` `        ``latestVowel.next = head;  ` `    ``}  ` ` `  `    ``// Now traverse the list. Curr is always the item  ` `    ``// *before* the one we are checking, so that we  ` `    ``// can use it to re-link.  ` `    ``while` `(curr != ``null` `&& curr.next != ``null``)  ` `    ``{  ` `        ``if` `(isVowel(curr.next.data) == ``true``)  ` `        ``{  ` `            ``// The next discovered item is a vowel  ` `            ``if` `(curr == latestVowel)  ` `            ``{  ` `                ``// If it comes directly after the  ` `                ``// previous vowel, we don't need to  ` `                ``// move items around, just mark the  ` `                ``// new latestVowel and advance curr.  ` `                ``latestVowel = curr = curr.next;  ` `            ``}  ` `            ``else` `            ``{  ` ` `  `                ``// But if it comes after an intervening  ` `                ``// chain of consonants, we need to chain  ` `                ``// the newly discovered vowel right after  ` `                ``// the old vowel. Curr is not changed as  ` `                ``// after the re-linking it will have a  ` `                ``// new next, that has not been checked yet,  ` `                ``// and we always keep curr at one before  ` `                ``// the next to check.  ` `                ``Node temp = latestVowel.next;  ` ` `  `                ``// Chain in new vowel  ` `                ``latestVowel.next = curr.next;  ` ` `  `                ``// Advance latestVowel  ` `                ``latestVowel = latestVowel.next;  ` ` `  `                ``// Remove found vowel from previous place  ` `                ``curr.next = curr.next.next;  ` ` `  `                ``// Re-link chain of consonants after latestVowel  ` `                ``latestVowel.next = temp;  ` `            ``}  ` `        ``}  ` `        ``else` `        ``{  ` ` `  `            ``// No vowel in the next element, advance curr.  ` `            ``curr = curr.next;  ` `        ``}  ` `    ``}  ` `    ``return` `newHead;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``Node head = newNode(``'a'``);  ` `    ``head.next = newNode(``'b'``);  ` `    ``head.next.next = newNode(``'c'``);  ` `    ``head.next.next.next = newNode(``'e'``);  ` `    ``head.next.next.next.next = newNode(``'d'``);  ` `    ``head.next.next.next.next.next = newNode(``'o'``);  ` `    ``head.next.next.next.next.next.next = newNode(``'x'``);  ` `    ``head.next.next.next.next.next.next.next = newNode(``'i'``);  ` ` `  `    ``System.out.println(``"Linked list before : "``);  ` `    ``printlist(head);  ` ` `  `    ``head = arrange(head);  ` ` `  `    ``System.out.println(``"Linked list after :"``);  ` `    ``printlist(head);  ` `} ` `}  ` ` `  `// This code is contributed by Prerna Saini. `

C#

 `/* C# program to arrange consonants and  ` `vowels nodes in a linked list */` `using` `System;  ` ` `  `class` `GfG ` `{  ` ` `  `    ``/* A linked list node */` `    ``public` `class` `Node  ` `    ``{  ` `        ``public` `char` `data;  ` `        ``public` `Node next;  ` `    ``} ` ` `  `    ``/* Function to add new node to the List */` `    ``static` `Node newNode(``char` `key)  ` `    ``{  ` `        ``Node temp = ``new` `Node();  ` `        ``temp.data = key;  ` `        ``temp.next = ``null``;  ` `        ``return` `temp;  ` `    ``}  ` ` `  `    ``// utility function to print linked list  ` `    ``static` `void` `printlist(Node head)  ` `    ``{  ` `        ``if` `(head == ``null``)  ` `        ``{  ` `            ``Console.WriteLine(``"Empty List"``);  ` `            ``return``;  ` `        ``}  ` `        ``while` `(head != ``null``)  ` `        ``{  ` `            ``Console.Write(head.data +``" "``);  ` `            ``if` `(head.next != ``null``)  ` `                ``Console.Write(``"-> "``);  ` `            ``head = head.next;  ` `        ``}  ` `        ``Console.WriteLine(); ` `    ``}  ` ` `  `    ``// utility function for checking vowel  ` `    ``static` `bool` `isVowel(``char` `x)  ` `    ``{  ` `        ``return` `(x == ``'a'` `|| x == ``'e'` `|| x == ``'i'` `||  ` `                ``x == ``'o'` `|| x == ``'u'``);  ` `    ``}  ` ` `  `    ``/* function to arrange consonants and  ` `    ``vowels nodes */` `    ``static` `Node arrange(Node head)  ` `    ``{  ` `        ``Node newHead = head;  ` ` `  `        ``// for keep track of vowel  ` `        ``Node latestVowel;  ` ` `  `        ``Node curr = head;  ` ` `  `        ``// list is empty  ` `        ``if` `(head == ``null``)  ` `            ``return` `null``;  ` ` `  `        ``// We need to discover the first vowel  ` `        ``// in the list. It is going to be the  ` `        ``// returned head, and also the initial  ` `        ``// latestVowel.  ` `        ``if` `(isVowel(head.data) == ``true``)  ` ` `  `            ``// first element is a vowel. It will  ` `            ``// also be the new head and the initial  ` `            ``// latestVowel;  ` `            ``latestVowel = head;  ` ` `  `        ``else` `        ``{  ` ` `  `            ``// First element is not a vowel. Iterate  ` `            ``// through the list until we find a vowel.  ` `            ``// Note that curr points to the element  ` `            ``// *before* the element with the vowel.  ` `            ``while` `(curr.next != ``null` `&&  ` `                ``!isVowel(curr.next.data))  ` `                ``curr = curr.next;  ` ` `  ` `  `            ``// This is an edge case where there are  ` `            ``// only consonants in the list.  ` `            ``if` `(curr.next == ``null``)  ` `                ``return` `head;  ` ` `  `            ``// Set the initial latestVowel and the  ` `            ``// new head to the vowel item that we found.  ` `            ``// Relink the chain of consonants after  ` `            ``// that vowel item:  ` `            ``// old_head_consonant->consonant1->consonant2->  ` `            ``// vowel->rest_of_list becomes  ` `            ``// vowel->old_head_consonant->consonant1->  ` `            ``// consonant2->rest_of_list  ` `            ``latestVowel = newHead = curr.next;  ` `            ``curr.next = curr.next.next;  ` `            ``latestVowel.next = head;  ` `        ``}  ` ` `  `        ``// Now traverse the list. Curr is always the item  ` `        ``// *before* the one we are checking, so that we  ` `        ``// can use it to re-link.  ` `        ``while` `(curr != ``null` `&& curr.next != ``null``)  ` `        ``{  ` `            ``if` `(isVowel(curr.next.data) == ``true``)  ` `            ``{  ` `                ``// The next discovered item is a vowel  ` `                ``if` `(curr == latestVowel)  ` `                ``{  ` `                    ``// If it comes directly after the  ` `                    ``// previous vowel, we don't need to  ` `                    ``// move items around, just mark the  ` `                    ``// new latestVowel and advance curr.  ` `                    ``latestVowel = curr = curr.next;  ` `                ``}  ` `                ``else` `                ``{  ` ` `  `                    ``// But if it comes after an intervening  ` `                    ``// chain of consonants, we need to chain  ` `                    ``// the newly discovered vowel right after  ` `                    ``// the old vowel. Curr is not changed as  ` `                    ``// after the re-linking it will have a  ` `                    ``// new next, that has not been checked yet,  ` `                    ``// and we always keep curr at one before  ` `                    ``// the next to check.  ` `                    ``Node temp = latestVowel.next;  ` ` `  `                    ``// Chain in new vowel  ` `                    ``latestVowel.next = curr.next;  ` ` `  `                    ``// Advance latestVowel  ` `                    ``latestVowel = latestVowel.next;  ` ` `  `                    ``// Remove found vowel from previous place  ` `                    ``curr.next = curr.next.next;  ` ` `  `                    ``// Re-link chain of consonants after latestVowel  ` `                    ``latestVowel.next = temp;  ` `                ``}  ` `            ``}  ` `            ``else` `            ``{  ` ` `  `                ``// No vowel in the next element, advance curr.  ` `                ``curr = curr.next;  ` `            ``}  ` `        ``}  ` `        ``return` `newHead;  ` `    ``}  ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{  ` `        ``Node head = newNode(``'a'``);  ` `        ``head.next = newNode(``'b'``);  ` `        ``head.next.next = newNode(``'c'``);  ` `        ``head.next.next.next = newNode(``'e'``);  ` `        ``head.next.next.next.next = newNode(``'d'``);  ` `        ``head.next.next.next.next.next = newNode(``'o'``);  ` `        ``head.next.next.next.next.next.next = newNode(``'x'``);  ` `        ``head.next.next.next.next.next.next.next = newNode(``'i'``);  ` ` `  `        ``Console.WriteLine(``"Linked list before : "``);  ` `        ``printlist(head);  ` ` `  `        ``head = arrange(head);  ` ` `  `        ``Console.WriteLine(``"Linked list after :"``);  ` `        ``printlist(head);  ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Python3

 `# Python3 program to remove vowels ` `# Nodes in a linked list ` ` `  `# A linked list node ` `class` `Node: ` `    ``def` `__init__(``self``, x): ` `        ``self``.data ``=` `x ` `        ``self``.``next` `=` `None` ` `  `# Utility function to print the ` `# linked list ` `def` `printlist(head): ` `    ``if` `(``not` `head): ` `        ``print``(``"Empty List"``) ` `        ``return` ` `  `    ``while` `(head !``=` `None``): ` `        ``print``(head.data, end ``=` `" "``) ` `        ``if` `(head.``next``): ` `            ``print``(end ``=` `"-> "``) ` `        ``head ``=` `head.``next` `    ``print``() ` ` `  `# Utility function for checking vowel ` `def` `isVowel(x): ` `    ``return` `(x ``=``=` `'a'` `or` `x ``=``=` `'e'` `or` `x ``=``=` `'i'` `            ``or` `x ``=``=` `'o'` `or` `x ``=``=` `'u'` `or` `x ``=``=` `'A'` `            ``or` `x ``=``=` `'E'` `or` `x ``=``=` `'I'` `or` `x ``=``=` `'O'` `            ``or` `x ``=``=` `'U'``) ` ` `  `#/* function to arrange consonants and ` `#   vowels nodes */ ` `def` `arrange(head): ` `    ``newHead ``=` `head ` ` `  `    ``# for keep track of vowel ` `    ``latestVowel ``=` `None` ` `  `    ``curr ``=` `head ` ` `  `    ``# list is empty ` `    ``if` `(head ``=``=` `None``): ` `        ``return` `None` ` `  `    ``# We need to discover the first vowel ` `    ``# in the list. It is going to be the ` `    ``# returned head, and also the initial ` `    ``# latestVowel. ` `    ``if` `(isVowel(head.data)): ` ` `  `        ``# first element is a vowel. It will ` `        ``# also be the new head and the initial ` `        ``# latestVowel ` `        ``latestVowel ``=` `head ` ` `  `    ``else``: ` ` `  `        ``# First element is not a vowel. Iterate ` `        ``# through the list until we find a vowel. ` `        ``# Note that curr points to the element ` `        ``# *before* the element with the vowel. ` `        ``while` `(curr.``next` `!``=` `None` `and` `               ``not` `isVowel(curr.``next``.data)): ` `            ``curr ``=` `curr.``next` ` `  ` `  `        ``# This is an edge case where there are ` `        ``# only consonants in the list. ` `        ``if` `(curr.``next` `=``=` `None``): ` `            ``return` `head ` ` `  `        ``# Set the initial latestVowel and the ` `        ``# new head to the vowel item that we found. ` `        ``# Relink the chain of consonants after ` `        ``# that vowel item: ` `        ``# old_head_consonant.consonant1.consonant2. ` `        ``# vowel.rest_of_list becomes ` `        ``# vowel.old_head_consonant.consonant1. ` `        ``# consonant2.rest_of_list ` `        ``latestVowel ``=` `newHead ``=` `curr.``next` `        ``curr.``next` `=` `curr.``next``.``next` `        ``latestVowel.``next` `=` `head ` ` `  `    ``# Now traverse the list. Curr is always the item ` `    ``# *before* the one we are checking, so that we ` `    ``# can use it to re-link. ` `    ``while` `(curr !``=` `None` `and` `curr.``next` `!``=` `None``): ` `        ``if` `(isVowel(curr.``next``.data)): ` `             `  `            ``# The next discovered item is a vowel ` `            ``if` `(curr ``=``=` `latestVowel): ` `                ``# If it comes directly after the ` `                ``# previous vowel, we don't need to ` `                ``# move items around, just mark the ` `                ``# new latestVowel and advance curr. ` `                ``latestVowel ``=` `curr ``=` `curr.``next` `            ``else``: ` ` `  `                ``# But if it comes after an intervening ` `                ``# chain of consonants, we need to chain ` `                ``# the newly discovered vowel right after ` `                ``# the old vowel. Curr is not changed as ` `                ``# after the re-linking it will have a ` `                ``# new next, that has not been checked yet, ` `                ``# and we always keep curr at one before ` `                ``# the next to check. ` `                ``temp ``=` `latestVowel.``next` ` `  `                ``# Chain in new vowel ` `                ``latestVowel.``next` `=` `curr.``next` ` `  `                ``# Advance latestVowel ` `                ``latestVowel ``=` `latestVowel.``next` ` `  `                ``# Remove found vowel from previous place ` `                ``curr.``next` `=` `curr.``next``.``next` ` `  `                ``# Re-link chain of consonants after latestVowel ` `                ``latestVowel.``next` `=` `temp ` ` `  `        ``else``: ` ` `  `            ``# No vowel in the next element, advance curr. ` `            ``curr ``=` `curr.``next` ` `  `    ``return` `newHead ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``# Initialise the Linked List ` `    ``head ``=` `Node(``'a'``) ` `    ``head.``next` `=` `Node(``'b'``) ` `    ``head.``next``.``next` `=` `Node(``'c'``) ` `    ``head.``next``.``next``.``next` `=` `Node(``'e'``) ` `    ``head.``next``.``next``.``next``.``next` `=` `Node(``'d'``) ` `    ``head.``next``.``next``.``next``.``next``.``next` `=` `Node(``'o'``) ` `    ``head.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``'x'``) ` `    ``head.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``'i'``) ` ` `  `    ``# Print the given Linked List ` `    ``print``(``"Linked list before :"``) ` `    ``printlist(head) ` ` `  `    ``head ``=` `arrange(head) ` ` `  `    ``# Print the Linked List after ` `    ``# removing vowels ` `    ``print``(``"Linked list after :"``) ` `    ``printlist(head) ` ` `  `# This code is contributed by mohit kumar 29`

Javascript

 ` `

Output:

```Linked list before :
a -> b -> c -> e -> d -> o -> x -> i
a -> e -> o -> i -> b -> c -> d -> x```

TIME COMPLEXITY:- O(n)

SPACE COMPLEXITY:- O(1)

References:
Stackoverflow
This article is contributed by Gaurav Miglani. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Another approach:-

Another approach to solve the above problem is to create two separate Linked List one containing only vowels and the other one containing only consonant.

Remember the below approach is simple to understand BUT IT REQUIRES A SPACE COMPLEXITY OF O(N)

While traversing the given input Linked List if the node data is vowel then add it to the vowel Linked List and if the node data is consonant then add it to the consonant Linked List.

After traversal you have to just link the last vowel node to the first consonant node of the respective Linked List.

C++

 `/* C++ program to arrange consonants and ` `vowels nodes in a linked list */` `#include ` `using` `namespace` `std; ` ` `  `/* A linked list node */` `struct` `Node { ` `    ``char` `data; ` `    ``struct` `Node* next; ` `    ``Node(``int` `x) ` `    ``{ ` `        ``data = x; ` `        ``next = NULL; ` `    ``} ` `}; ` ` `  `/* Function to add new node to the List */` `void` `append(``struct` `Node** headRef, ``char` `data) ` `{ ` `    ``struct` `Node* new_node = ``new` `Node(data); ` `    ``struct` `Node* last = *headRef; ` `    ``if` `(*headRef == NULL) { ` `        ``*headRef = new_node; ` `        ``return``; ` `    ``} ` `    ``while` `(last->next != NULL) ` `        ``last = last->next; ` `    ``last->next = new_node; ` `    ``return``; ` `} ` ` `  `// utility function to print linked list ` `void` `printlist(Node* head) ` `{ ` `    ``if` `(!head) { ` `        ``cout << ``"Empty List\n"``; ` `        ``return``; ` `    ``} ` `    ``while` `(head != NULL) { ` `        ``cout << head->data << ``" "``; ` `        ``if` `(head->next) ` `            ``cout << ``"-> "``; ` `        ``head = head->next; ` `    ``} ` `    ``cout << endl; ` `} ` ` `  `/* function to arrange consonants and ` `vowels nodes */` ` `  `struct` `Node* arrange(Node* head) ` `{ ` `    ``Node *vowel = NULL, *consonant = NULL, *start = NULL, ` `         ``*end = NULL; ` `    ``while` `(head != NULL) { ` `        ``char` `x = head->data; ` `        ``// Checking the current node data is vowel or ` `        ``// not ` `        ``if` `(x == ``'a'` `|| x == ``'e'` `|| x == ``'i'` `|| x == ``'o'` `            ``|| x == ``'u'``) { ` `            ``if` `(!vowel) { ` `                ``vowel = ``new` `Node(x); ` `                ``start = vowel; ` `            ``} ` `            ``else` `{ ` `                ``vowel->next = ``new` `Node(x); ` `                ``vowel = vowel->next; ` `            ``} ` `        ``} ` `        ``else` `{ ` `            ``if` `(!consonant) { ` `                ``consonant = ``new` `Node(x); ` `                ``end = consonant; ` `            ``} ` `            ``else` `{ ` `                ``consonant->next = ``new` `Node(x); ` `                ``consonant = consonant->next; ` `            ``} ` `        ``} ` `        ``head = head->next; ` `    ``} ` `    ``// In case when there is no vowel in the incoming LL ` `    ``// then we have to return the head of the consonant LL ` `    ``if` `(start == NULL) ` `        ``return` `end; ` `    ``// Connecting the vowel and consonant LL ` `    ``vowel->next = end; ` `    ``return` `start; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``struct` `Node* head = NULL; ` `    ``append(&head, ``'a'``); ` `    ``append(&head, ``'b'``); ` `    ``append(&head, ``'c'``); ` `    ``append(&head, ``'e'``); ` `    ``append(&head, ``'d'``); ` `    ``append(&head, ``'o'``); ` `    ``append(&head, ``'x'``); ` `    ``append(&head, ``'i'``); ` ` `  `    ``printf``(``"Linked list before :\n"``); ` `    ``printlist(head); ` ` `  `    ``head = arrange(head); ` ` `  `    ``printf``(``"Linked list after :\n"``); ` `    ``printlist(head); ` ` `  `    ``return` `0; ` `} ` ` `  `// This code is contributed by Aditya Kumar`

Java

 `/* Java program to arrange consonants and ` `vowels nodes in a linked list */` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `/* A linked list node */` `static` `class` `Node { ` `    ``char` `data; ` `    ``Node next; ` `    ``Node(``char` `x) ` `    ``{ ` `        ``this``.data = x; ` `        ``this``.next = ``null``; ` `    ``} ` `}; ` ` `  `/* Function to add new node to the List */` `static` `Node append(Node headRef, ``char` `data) ` `{ ` `    ``Node new_node = ``new` `Node(data); ` `    ``Node last = headRef; ` `    ``if` `(headRef == ``null``) { ` `        ``headRef = new_node; ` `        ``return` `headRef; ` `    ``} ` `    ``while` `(last.next != ``null``) ` `        ``last = last.next; ` `    ``last.next = new_node; ` `    ``return` `headRef; ` `} ` ` `  `// utility function to print linked list ` `static` `void` `printlist(Node head) ` `{ ` `    ``if` `(head == ``null``) { ` `        ``System.out.print(``"Empty List\n"``); ` `        ``return``; ` `    ``} ` `    ``while` `(head != ``null``) { ` `        ``System.out.print(head.data+ ``" "``); ` `        ``if` `(head.next!=``null``) ` `            ``System.out.print(``"-> "``); ` `        ``head = head.next; ` `    ``} ` `    ``System.out.println(); ` `} ` ` `  `/* function to arrange consonants and ` `vowels nodes */` ` `  `@SuppressWarnings``(``"null"``) ` `static` `Node arrange(Node head) ` `{ ` `    ``Node vowel = ``null``, consonant = ``null``, start = ``null``, ` `         ``end = ``null``; ` `    ``while` `(head != ``null``) { ` `        ``char` `x = head.data; ` `       `  `        ``// Checking the current node data is vowel or ` `        ``// not ` `        ``if` `(x == ``'a'` `|| x == ``'e'` `|| x == ``'i'` `|| x == ``'o'` `            ``|| x == ``'u'``) { ` `            ``if` `(vowel==``null``) { ` `                ``vowel = ``new` `Node(x); ` `                ``start = vowel; ` `            ``} ` `            ``else` `{ ` `                ``vowel.next = ``new` `Node(x); ` `                ``vowel = vowel.next; ` `            ``} ` `        ``} ` `        ``else` `{ ` `            ``if` `(consonant == ``null``) { ` `                ``consonant = ``new` `Node(x); ` `                ``end = consonant; ` `            ``} ` `            ``else` `{ ` `                ``consonant.next = ``new` `Node(x); ` `                ``consonant = consonant.next; ` `            ``} ` `        ``} ` `        ``head = head.next; ` `    ``} ` `   `  `    ``// In case when there is no vowel in the incoming LL ` `    ``// then we have to return the head of the consonant LL ` `    ``if` `(start == ``null``) ` `        ``return` `end; ` `   `  `    ``// Connecting the vowel and consonant LL ` `    ``vowel.next = end; ` `    ``return` `start; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``Node head = ``null``; ` `    ``head = append(head, ``'a'``); ` `    ``head = append(head, ``'b'``); ` `    ``head = append(head, ``'c'``); ` `    ``head = append(head, ``'e'``); ` `    ``head = append(head, ``'d'``); ` `    ``head = append(head, ``'o'``); ` `    ``head = append(head, ``'x'``); ` `    ``head = append(head, ``'i'``); ` ` `  `    ``System.out.printf(``"Linked list before :\n"``); ` `    ``printlist(head); ` ` `  `    ``head = arrange(head); ` ` `  `    ``System.out.printf(``"Linked list after :\n"``); ` `    ``printlist(head); ` ` `  `} ` `} ` ` `  `// This code is contributed by Rajput-Ji  `

Python3

 `''' Python program to arrange consonants and ` `vowels Nodes in a linked list '''` ` `  `''' A linked list Node '''` `class` `Node:  ` `    ``def` `__init__(``self``, data): ` `        ``self``.data ``=` `data;  ` `        ``self``.``next` `=` `None``; ` `     `  `''' Function to add new Node to the List '''` `def` `append(headRef,  data): ` `    ``new_Node ``=`  `Node(data); ` `    ``last ``=` `headRef; ` `    ``if` `(headRef ``=``=` `None``): ` `        ``headRef ``=` `new_Node; ` `        ``return` `headRef; ` `     `  `    ``while` `(last.``next` `!``=` `None``): ` `        ``last ``=` `last.``next``; ` `    ``last.``next` `=` `new_Node; ` `    ``return` `headRef; ` ` `  `# utility function to print linked list ` `def` `printlist(head): ` `    ``if` `(head ``=``=` `None``): ` `        ``print``(``"Empty List"``); ` `        ``return``; ` `     `  `    ``while` `(head !``=` `None``): ` `        ``print``(head.data, end``=``""); ` `        ``if` `(head.``next` `!``=` `None``): ` `            ``print``(``"-> "``,end``=``""); ` `        ``head ``=` `head.``next``; ` `     `  `    ``print``(); ` ` `  ` `  `''' ` ` ``* function to arrange consonants and vowels Nodes ` ` ``'''` `def` `arrange(head): ` `    ``vowel ``=` `None``; ` `    ``consonant ``=` `None``; ` `    ``start ``=` `None``; ` `    ``end ``=` `None``; ` `    ``while` `(head !``=` `None``): ` `        ``x ``=` `head.data; ` ` `  `        ``# Checking the current Node data is vowel or ` `        ``# not ` `        ``if` `(x ``=``=` `'a'` `or` `x ``=``=` `'e'` `or` `x ``=``=` `'i'` `or` `x ``=``=` `'o'` `or` `x ``=``=` `'u'``): ` `            ``if` `(vowel ``=``=` `None``): ` `                ``vowel ``=`  `Node(x); ` `                ``start ``=` `vowel; ` `            ``else``: ` `                ``vowel.``next` `=`  `Node(x); ` `                ``vowel ``=` `vowel.``next``; ` `             `  `        ``else``: ` `            ``if` `(consonant ``=``=` `None``): ` `                ``consonant ``=`  `Node(x); ` `                ``end ``=` `consonant; ` `            ``else``: ` `                ``consonant.``next` `=`  `Node(x); ` `                ``consonant ``=` `consonant.``next``; ` `             `  `         `  `        ``head ``=` `head.``next``; ` `     `  `    ``# In case when there is no vowel in the incoming LL ` `    ``# then we have to return the head of the consonant LL ` `    ``if` `(start ``=``=` `None``): ` `        ``return` `end; ` ` `  `    ``# Connecting the vowel and consonant LL ` `    ``vowel.``next` `=` `end; ` `    ``return` `start; ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``head ``=` `None``; ` `    ``head ``=` `append(head, ``'a'``); ` `    ``head ``=` `append(head, ``'b'``); ` `    ``head ``=` `append(head, ``'c'``); ` `    ``head ``=` `append(head, ``'e'``); ` `    ``head ``=` `append(head, ``'d'``); ` `    ``head ``=` `append(head, ``'o'``); ` `    ``head ``=` `append(head, ``'x'``); ` `    ``head ``=` `append(head, ``'i'``); ` ` `  `    ``print``(``"Linked list before :"``); ` `    ``printlist(head); ` ` `  `    ``head ``=` `arrange(head); ` ` `  `    ``print``(``"Linked list after :"``); ` `    ``printlist(head); ` ` `  `# This code is contributed by Rajput-Ji `

C#

 `/* C# program to arrange consonants and ` `vowels nodes in a linked list */` `using` `System; ` ` `  `public` `class` `GFG { ` ` `  `  ``/* A linked list node */` `  ``public`    `class` `Node { ` `    ``public`    `char` `data; ` `    ``public`    `Node next; ` ` `  `    ``public`    `Node(``char` `x) { ` `      ``this``.data = x; ` `      ``this``.next = ``null``; ` `    ``} ` `  ``}; ` ` `  `  ``/* Function to add new node to the List */` `  ``static` `Node append(Node headRef, ``char` `data) { ` `    ``Node new_node = ``new` `Node(data); ` `    ``Node last = headRef; ` `    ``if` `(headRef == ``null``) { ` `      ``headRef = new_node; ` `      ``return` `headRef; ` `    ``} ` `    ``while` `(last.next != ``null``) ` `      ``last = last.next; ` `    ``last.next = new_node; ` `    ``return` `headRef; ` `  ``} ` ` `  `  ``// utility function to print linked list ` `  ``static` `void` `printlist(Node head) { ` `    ``if` `(head == ``null``) { ` `      ``Console.Write(``"Empty List\n"``); ` `      ``return``; ` `    ``} ` `    ``while` `(head != ``null``) { ` `      ``Console.Write(head.data + ``" "``); ` `      ``if` `(head.next != ``null``) ` `        ``Console.Write(``"-> "``); ` `      ``head = head.next; ` `    ``} ` `    ``Console.WriteLine(); ` `  ``} ` ` `  `  ``/* ` `     ``* function to arrange consonants and vowels nodes ` `     ``*/` ` `  `  ``static` `Node arrange(Node head) { ` `    ``Node vowel = ``null``, consonant = ``null``, start = ``null``, end = ``null``; ` `    ``while` `(head != ``null``) { ` `      ``char` `x = head.data; ` ` `  `      ``// Checking the current node data is vowel or ` `      ``// not ` `      ``if` `(x == ``'a'` `|| x == ``'e'` `|| x == ``'i'` `|| x == ``'o'` `|| x == ``'u'``) { ` `        ``if` `(vowel == ``null``) { ` `          ``vowel = ``new` `Node(x); ` `          ``start = vowel; ` `        ``} ``else` `{ ` `          ``vowel.next = ``new` `Node(x); ` `          ``vowel = vowel.next; ` `        ``} ` `      ``} ``else` `{ ` `        ``if` `(consonant == ``null``) { ` `          ``consonant = ``new` `Node(x); ` `          ``end = consonant; ` `        ``} ``else` `{ ` `          ``consonant.next = ``new` `Node(x); ` `          ``consonant = consonant.next; ` `        ``} ` `      ``} ` `      ``head = head.next; ` `    ``} ` ` `  `    ``// In case when there is no vowel in the incoming LL ` `    ``// then we have to return the head of the consonant LL ` `    ``if` `(start == ``null``) ` `      ``return` `end; ` ` `  `    ``// Connecting the vowel and consonant LL ` `    ``vowel.next = end; ` `    ``return` `start; ` `  ``} ` ` `  `  ``// Driver code ` `  ``public` `static` `void` `Main(String[] args) { ` `    ``Node head = ``null``; ` `    ``head = append(head, ``'a'``); ` `    ``head = append(head, ``'b'``); ` `    ``head = append(head, ``'c'``); ` `    ``head = append(head, ``'e'``); ` `    ``head = append(head, ``'d'``); ` `    ``head = append(head, ``'o'``); ` `    ``head = append(head, ``'x'``); ` `    ``head = append(head, ``'i'``); ` ` `  `    ``Console.Write(``"Linked list before :\n"``); ` `    ``printlist(head); ` ` `  `    ``head = arrange(head); ` ` `  `    ``Console.Write(``"Linked list after :\n"``); ` `    ``printlist(head); ` ` `  `  ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Javascript

 ` `

TIME COMPLEXITY:- O(n)

SPACE COMPLEXITY:- O(n)

My Personal Notes arrow_drop_up
Recommended Articles
Page :