Remove all special characters from a singly Linked List

Given a singly linked list where each node represents a character including special characters, the task is to remove all the occurrences of special characters from the linked list so that only valid characters are present in the linked list.

Examples:

Input: List = ( -> G -> E -> E -> * -> K -> S -> * -> NULL
Output: G -> E -> E -> K -> S -> NULL

Input: A -> B -> C -> * -> @ -> NULL
Output: A -> B -> C -> NULL

Approach: Traverse the linked list, if the current node’s data is a special character then make the next of the previous node point to the next of the current node. Do this for every node with a special character and finally print the updated list.



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
using namespace std;
  
// Structure for the node
// of the linked list
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;
  
    // Assign the data to the data part
    // and assign NULL to the address part
    newnode->data = data;
    newnode->next = NULL;
    return newnode;
}
  
// Function to print the linked list
void print(node* head)
{
    while (head != NULL) {
        cout << head->data << " -> ";
        head = head->next;
    }
    cout << "NULL";
}
  
// Function that returns true if
// ch is a special character
bool isSpecialChar(char ch)
{
  
    // If lower-case character
    if (ch >= 'a' && ch <= 'z')
        return false;
  
    // If upper-case character
    if (ch >= 'A' && ch <= 'Z')
        return false;
  
    // If digit
    if (ch >= '0' && ch <= '9')
        return false;
  
    // ch is a special character
    return true;
}
  
// Function to remove the special
// characters from the linked list
node* removeFromLL(node* head)
{
  
    // Declare two variables curr and
    // prev both pointing to head
    node *curr = head, *prev = head;
  
    // The following loop removes special
    // characters from the head of the linked list
    // In case the special character is present at
    // the head of the linked list, make head point
    // to the next valid character
    while (curr != NULL && isSpecialChar(curr->data)) {
        node* temp = curr;
        head = curr->next;
        curr = curr->next;
        delete temp;
    }
  
    // Make prev point to head
    prev = head;
  
    // Repeat the process for
    // the entire Linked list
    while (curr != NULL) {
  
        // Repeat the process for all the elements
        // of linked list, in case a special character
        // is encountered then make the previous valid
        // character point to the next valid character
        // and remove the current node from the linked list
        while (curr != NULL && isSpecialChar(curr->data)) {
            node* temp = curr;
            prev->next = curr->next;
            curr = curr->next;
            delete temp;
        }
  
        // If the end is reached
        if (curr == NULL)
            break;
        prev = curr;
        curr = curr->next;
    }
    return head;
}
  
// Driver code
int main()
{
  
    // Create the linked list
    node* head = NULL;
    head = add('(');
    head->next = add('G');
    head->next->next = add('E');
    head->next->next->next = add('E');
    head->next->next->next->next = add('*');
    head->next->next->next->next->next = add('K');
    head->next->next->next->next->next->next = add('S');
    head->next->next->next->next->next->next->next = add('*');
  
    // Remove the special characters
    // from the linked list
    head = removeFromLL(head);
  
    // Print the updated list
    print(head);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG
{
  
// Structure for the node
// of the linked list
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();
  
    // Assign the data to the data part
    // and assign null to the address part
    newnode.data = data;
    newnode.next = null;
    return newnode;
}
  
// Function to print the linked list
static void print(node head)
{
    while (head != null
    {
        System.out.print(head.data + " -> ");
        head = head.next;
    }
    System.out.print("null");
}
  
// Function that returns true if
// ch is a special character
static boolean isSpecialChar(char ch)
{
  
    // If lower-case character
    if (ch >= 'a' && ch <= 'z')
        return false;
  
    // If upper-case character
    if (ch >= 'A' && ch <= 'Z')
        return false;
  
    // If digit
    if (ch >= '0' && ch <= '9')
        return false;
  
    // ch is a special character
    return true;
}
  
// Function to remove the special
// characters from the linked list
static node removeFromLL(node head)
{
  
    // Declare two variables curr and
    // prev both pointing to head
    node curr = head; node prev = head;
  
    // The following loop removes special
    // characters from the head of the linked list
    // In case the special character is present at
    // the head of the linked list, make head point
    // to the next valid character
    while (curr != null && 
           isSpecialChar(curr.data)) 
    {
        node temp = curr;
        head = curr.next;
        curr = curr.next;
        temp = null;
    }
  
    // Make prev point to head
    prev = head;
  
    // Repeat the process for
    // the entire Linked list
    while (curr != null)
    {
  
        // Repeat the process for all the elements
        // of linked list, in case a special character
        // is encountered then make the previous valid
        // character point to the next valid character
        // and remove the current node from the linked list
        while (curr != null &&
               isSpecialChar(curr.data))
        {
            node temp = curr;
            prev.next = curr.next;
            curr = curr.next;
            temp = null;
        }
  
        // If the end is reached
        if (curr == null)
            break;
        prev = curr;
        curr = curr.next;
    }
    return head;
}
  
// Driver code
public static void main(String[] args)
{
    // Create the linked list
    node head = null;
    head = add('(');
    head.next = add('G');
    head.next.next = add('E');
    head.next.next.next = add('E');
    head.next.next.next.next = add('*');
    head.next.next.next.next.next = add('K');
    head.next.next.next.next.next.next = add('S');
    head.next.next.next.next.next.next.next = add('*');
  
    // Remove the special characters
    // from the linked list
    head = removeFromLL(head);
  
    // Print the updated list
    print(head);
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
import math 
  
# Structure for the node
# of the linked list
class Node: 
    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 = Node(data)
  
    # Assign the data to the data part
    # and assign None to the address part
    newnode.data = data
    newnode.next = None
    return newnode
  
# Function to print the linked list
def printlist(head):
    while (head != None) :
        print(head.data, end = " -> ")
        head = head.next
      
    print("None")
  
# Function that returns true if
# ch is a special character
def isSpecialChar(ch):
  
    # If lower-case character
    if (ch >= 'a' and ch <= 'z'):
        return False
  
    # If upper-case character
    if (ch >= 'A' and ch <= 'Z'):
        return False
  
    # If digit
    if (ch >= '0' and ch <= '9'):
        return False
  
    # ch is a special character
    return True
  
# Function to remove the special
# characters from the linked list
def removeFromLL(head):
  
    # Declare two variables curr and
    # prev both pointing to head
    curr = head
    prev = head
  
    # The following loop removes special
    # characters from the head of the linked list
    # In case the special character is present at
    # the head of the linked list, make head point
    # to the next valid character
    while (curr != None and 
           isSpecialChar(curr.data)):
        temp = curr
        head = curr.next
        curr = curr.next
        temp = None
      
    # Make prev point to head
    prev = head
  
    # Repeat the process for
    # the entire Linked list
    while (curr != None):
  
        # Repeat the process for all the elements
        # of linked list, in case a special character
        # is encountered then make the previous valid
        # character point to the next valid character
        # and remove the current node from the linked list
        while (curr != None and 
               isSpecialChar(curr.data)):
            temp = curr
            prev.next = curr.next
            curr = curr.next
            temp = None
          
        # If the end is reached
        if (curr == None):
            break
        prev = curr
        curr = curr.next
      
    return head
  
# Driver code
if __name__=='__main__':
  
    # Create the linked list
    head = None
    head = add('(')
    head.next = add('G')
    head.next.next = add('E')
    head.next.next.next = add('E')
    head.next.next.next.next = add('*')
    head.next.next.next.next.next = add('K')
    head.next.next.next.next.next.next = add('S')
    head.next.next.next.next.next.next.next = add('*')
  
    # Remove the special characters
    # from the linked list
    head = removeFromLL(head)
  
    # Print the updated list
    printlist(head)
  
# This code is contributed by Srathore

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
      
class GFG
{
  
// Structure for the node
// of the linked list
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();
  
    // Assign the data to the data part
    // and assign null to the address part
    newnode.data = data;
    newnode.next = null;
    return newnode;
}
  
// Function to print the linked list
static void print(node head)
{
    while (head != null
    {
        Console.Write(head.data + " -> ");
        head = head.next;
    }
    Console.Write("null");
}
  
// Function that returns true if
// ch is a special character
static Boolean isSpecialChar(char ch)
{
  
    // If lower-case character
    if (ch >= 'a' && ch <= 'z')
        return false;
  
    // If upper-case character
    if (ch >= 'A' && ch <= 'Z')
        return false;
  
    // If digit
    if (ch >= '0' && ch <= '9')
        return false;
  
    // ch is a special character
    return true;
}
  
// Function to remove the special
// characters from the linked list
static node removeFromLL(node head)
{
  
    // Declare two variables curr and
    // prev both pointing to head
    node curr = head; node prev = head;
  
    // The following loop removes special
    // characters from the head of the linked list
    // In case the special character is present at
    // the head of the linked list, make head point
    // to the next valid character
    while (curr != null && 
           isSpecialChar(curr.data)) 
    {
        node temp = curr;
        head = curr.next;
        curr = curr.next;
        temp = null;
    }
  
    // Make prev point to head
    prev = head;
  
    // Repeat the process for
    // the entire Linked list
    while (curr != null)
    {
  
        // Repeat the process for all the elements
        // of linked list, in case a special character
        // is encountered then make the previous valid
        // character point to the next valid character
        // and remove the current node from the linked list
        while (curr != null &&
               isSpecialChar(curr.data))
        {
            node temp = curr;
            prev.next = curr.next;
            curr = curr.next;
            temp = null;
        }
  
        // If the end is reached
        if (curr == null)
            break;
        prev = curr;
        curr = curr.next;
    }
    return head;
}
  
// Driver code
public static void Main(String[] args)
{
    // Create the linked list
    node head = null;
    head = add('(');
    head.next = add('G');
    head.next.next = add('E');
    head.next.next.next = add('E');
    head.next.next.next.next = add('*');
    head.next.next.next.next.next = add('K');
    head.next.next.next.next.next.next = add('S');
    head.next.next.next.next.next.next.next = add('*');
  
    // Remove the special characters
    // from the linked list
    head = removeFromLL(head);
  
    // Print the updated list
    print(head);
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Output:

G -> E -> E -> K -> S -> NULL

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.