在链表中排列辅音和元音节点

给定一个单链表，我们需要安排它的辅音和元音节点，使所有元音节点都在辅音之前，同时保持它们到达的顺序。
例子：

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

解决方案 ：
这个想法是保留我们在遍历列表时发现的最新元音的标记。如果我们找到另一个元音，我们将它从链中取出并放在现有的最新元音之后。示例：对于链表：

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

假设我们的 latestVowel 引用引用了 'a' 节点，并且我们当前到达了 'e' 节点。我们的确是：

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

因此，在删除“a”节点并将“a”直接链接到“e”之后，“a”节点之后的内容现在位于“e”节点之后。
要正确删除和添加链接，最好在您检查的节点之前使用该节点。因此，如果您有curr ，您将检查curr->next节点以查看它是否是元音。如果是，我们需要将其添加到latestVowel 节点之后，然后通过将其next 分配给curr 的next 来轻松将其从链中移除。此外，如果列表仅包含辅音，我们只需返回 head。

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

 
/* JavaScript program to arrange consonants and
vowels nodes in a linked list */
     
     
 /* A linked list node */  
class Node
{
    /* Function to add new node to the List */
    constructor(key)
    {
        this.data=key;
        this.next = null;
    }
}
 
// utility function to print linked list
function printlist(head)
{
    if (head == null)
    {
        document.write("Empty List<br>");
        return;
    }
    while (head != null)
    {
        document.write(head.data +" ");
        if (head.next != null)
            document.write("-> ");
        head = head.next;
    }
    document.write("<br>");
}
 
// utility function for checking vowel
function isVowel(x)
{
    return (x == 'a' || x == 'e' || x == 'i' ||
            x == 'o' || x == 'u');
             
}
 
 
/* function to arrange consonants and
vowels nodes */
function arrange(head)
{
    let newHead = head;
  
    // for keep track of vowel
    let latestVowel;
  
    let 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.
                let 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
let head = new Node('a');
head.next = new Node('b');
head.next.next = new Node('c');
head.next.next.next = new Node('e');
head.next.next.next.next = new Node('d');
head.next.next.next.next.next = new Node('o');
head.next.next.next.next.next.next = new Node('x');
head.next.next.next.next.next.next.next = new Node('i');
 
document.write("Linked list before : <br>");
printlist(head);
 
head = arrange(head);
 
document.write("Linked list after :<br>");
printlist(head);
     
 
// This code is contributed by unknown2108
 

输出：

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。