Skip to content
Related Articles
Get the best out of our app
GeeksforGeeks App
Open App
geeksforgeeks
Browser
Continue

Related Articles

Reverse nodes of a linked list without affecting the special characters

Improve Article
Save Article
Like Article
author
Shahnawaz_Ali
scholar
68 published articles
Improve Article
Save Article
Like Article

Given a linked list of alphabets and special characters. Reverse the given linked list without affecting the position of the special characters. 

Examples:  

Input: g -> @ -> e -> # -> e -> $ -> k -> s -> NULL 
Output: s -> @ -> k -> # -> e -> $ -> e -> g -> NULL 
Explanation: Here we can see that in the output the position of special character in not change and also linked list is reverse.

The idea is to traverse the linked list and store the characters excluding the special characters in a temporary array. Again traverse the linked list and copy elements from the array to the nodes of the linked list in a reverse manner.

Below is the step by step algorithm:  

  1. Take a temporary array, TEMP_ARR.
  2. Traverse the linked list and do the following 
    • if the current element is an alphabet, store that element of the linked list to TEMP_ARR.
    • else, increase node pointer by one
  3. Again traverse the linked list from the head and TEMP_ARR from the end and do the following:
    • if the current element is an alphabet, copy the last element of TEMP_ARR to the current linked list node and decrease the current index of TEMP_ARR for the next iteration.
    • else, increase node by one

Below is the implementation of above approach:  

C++




// C++ program to reverse a linked list
// without affecting special characters
 
#include <iostream>
 
using namespace std;
 
// Link list node
struct Node {
    char data;
    struct Node* next;
};
 
// Function to reverse the linked list
// without affecting special characters
void reverse(struct Node** head_ref, int size)
{
    struct Node* current = *head_ref;
     
     
    char TEMP_ARR[size];
     
    int i = 0;
     
    // Traverse the linked list and insert
    // linked list elements to TEMP_ARR
    while (current != NULL) {
        // if the current data is any alphabet than
        // store it in to TEMP_ARR
        if ((current->data >= 97 && current->data <= 122) ||
                (current->data >= 65 && current->data <= 90)) {
            TEMP_ARR[i++] = current->data;
            current = current->next;
        }
        // else increase the node position
        else
            current = current->next;
    }
     
    current = *head_ref;
    // Traverse the linked list again
    while (current != NULL)
    {
        // if current character is an alphabet than
        // replace the current element in the linked list
        // with the last element of the TEMP_ARR
        if ((current->data >= 97 && current->data <= 122) ||
                (current->data >= 65 && current->data <= 90)) {
            current->data = TEMP_ARR[--i];
            current = current->next;
        }
        // else increase the node
        else
            current = current->next;
    }
}
 
// Function to push a node
void push(struct Node** head_ref, char new_data)
{
    /* allocate node */
    struct Node* new_node = new Node();
 
    /* put in the data */
    new_node->data = new_data;
 
    /* link the old list of the new node */
    new_node->next = (*head_ref);
 
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
/* Function to print linked list */
void printList(struct Node* head)
{
    struct Node* temp = head;
    while (temp != NULL) {
        cout << temp->data;
        temp = temp->next;
    }
}
 
// Driver program to test above function
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;
 
    push(&head, 's');
    push(&head, '$');
    push(&head, 'k');
    push(&head, 'e');
    push(&head, 'e');
    push(&head, '@');
    push(&head, '#');
    push(&head, 'g');
    push(&head, 'r');
    push(&head, 'o');
    push(&head, 'f');
    push(&head, 's');
    push(&head, '$');
    push(&head, 'k');
    push(&head, 'e');
    push(&head, 'e');
    push(&head, 'g');
 
    cout << "Given linked list: ";
    printList(head);
     
    reverse(&head, 13);
     
    cout << "\nReversed Linked list: ";
    printList(head);
     
    return 0;
}

Java



// Java program to reverse a
// linked list without affecting
// special characters
class GFG
{
 
// Link list node
public static class Node
{
    char data;
    Node next;
}
 
// Function to reverse the linked
// list without affecting special
// characters
static void reverse(Node head_ref,
                    int size)
{
Node current = head_ref;
 
 
char TEMP_ARR[] = new char[size];
 
int i = 0;
 
// Traverse the linked list
// and insert linked list
// elements to TEMP_ARR
while (current != null)
{
    // if the current data
    // is any alphabet than
    // store it in to TEMP_ARR
    if ((current.data >= 97 &&
         current.data <= 122) ||
        (current.data >= 65 &&
         current.data <= 90))
    {
        TEMP_ARR[i++] = current.data;
        current = current.next;
    }
     
    // else increase the node position
    else
        current = current.next;
}
 
current = head_ref;
 
// Traverse the linked list again
while (current != null)
{
    // if current character is an
    // alphabet than replace the
    // current element in the linked
    // list with the last element
    // of the TEMP_ARR
    if ((current.data >= 97 &&
         current.data <= 122) ||
        (current.data >= 65 &&
         current.data <= 90))
    {
        current.data = TEMP_ARR[--i];
        current = current.next;
    }
     
    // else increase the node
    else
        current = current.next;
    }
}
 
// Function to push a node
static Node push(Node head_ref,
                 char new_data)
{
    /* allocate node */
    Node new_node = new Node();
 
    /* put in the data */
    new_node.data = new_data;
 
    /* link the old list
       off the new node */
    new_node.next = (head_ref);
 
    /* move the head to point
       to the new node */
    (head_ref) = new_node;
     
    return head_ref;
}
 
/* Function to print linked list */
static void printList(Node head)
{
    Node temp = head;
    while (temp != null)
    {
        System.out.print(temp.data);
        temp = temp.next;
    }
}
 
// Driver Code
public static void main(String rags[])
{
    /* Start with the empty list */
    Node head = null;
 
    head = push(head, 's');
    head = push(head, '$');
    head = push(head, 'k');
    head = push(head, 'e');
    head = push(head, 'e');
    head = push(head, '@');
    head = push(head, '#');
    head = push(head, 'g');
    head = push(head, 'r');
    head = push(head, 'o');
    head = push(head, 'f');
    head = push(head, 's');
    head = push(head, '$');
    head = push(head, 'k');
    head = push(head, 'e');
    head = push(head, 'e');
    head = push(head, 'g');
 
    System.out.print( "Given linked list: ");
    printList(head);
     
    reverse(head, 13);
     
    System.out.print("\nReversed Linked list: ");
    printList(head);
}
}
 
// This code is contributed by Arnab Kundu
Python3



# Python3 program to reverse a linked list
# without affecting special characters
 
# Link list node
class Node:
     
    def __init__(self, x):
         
        self.data = x
        self.next = None
 
# Function to reverse the linked list
# without affecting special characters
def reverse(head_ref, size):
     
    current = head_ref
    TEMP_ARR = [0 for i in range(256)]
 
    i = 0
 
    # Traverse the linked list and insert
    # linked list elements to TEMP_ARR
    while (current != None):
         
        # If the current data is any alphabet than
        # store it in to TEMP_ARR
        if ((ord(current.data) >= 97 and
             ord(current.data) <= 122) or
            (ord(current.data) >= 65 and
             ord(current.data) <= 90)):
            TEMP_ARR[i]= current.data
            i += 1
            current = current.next
             
        # Else increase the node position
        else:
            current = current.next
 
    current = head_ref
     
    # Traverse the linked list again
    while (current != None):
         
        # If current character is an alphabet
        # than replace the current element in
        # the linked list with the last element
        # of the TEMP_ARR
        if ((ord(current.data) >= 97 and
             ord(current.data) <= 122) or
            (ord(current.data) >= 65 and
             ord(current.data) <= 90)):
            i = i - 1
            current.data = TEMP_ARR[i]
            current = current.next
             
        # Else increase the node
        else:
            current = current.next
             
    return head_ref
 
# Function to push a node
def push(head_ref, new_data):
     
    # Allocate node
    #new_node = (struct Node*)malloc(sizeof(struct Node));
 
    # Put in the data
    new_node = Node(new_data)
 
    # Link the old list of the new node
    new_node.next = head_ref
 
    # Move the head to point to the new node
    head_ref = new_node
 
    return head_ref
 
# Function to print linked list
def printList(head):
     
    temp = head
     
    while (temp != None):
        print(temp.data, end = "")
        temp = temp.next
 
# Driver code
if __name__ == '__main__':
     
    # Start with the empty list
    head = None
 
    head = push(head, 's')
    head = push(head, '$')
    head = push(head, 'k')
    head = push(head, 'e')
    head = push(head, 'e')
    head = push(head, '@')
    head = push(head, '#')
    head = push(head, 'g')
    head = push(head, 'r')
    head = push(head, 'o')
    head = push(head, 'f')
    head = push(head, 's')
    head = push(head, '$')
    head = push(head, 'k')
    head = push(head, 'e')
    head = push(head, 'e')
    head = push(head, 'g')
 
    print("Given linked list: ", end = "")
    printList(head)
 
    head = reverse(head, 13)
 
    print("\nReversed Linked list: ", end = "")
    printList(head)
 
# This code is contributed by mohit kumar 29
C#



// C# program to reverse a
// linked list without affecting
// special characters
using System;
 
class GFG
{
 
    // Link list node
    public class Node
    {
        public char data;
        public Node next;
    }
 
    // Function to reverse the linked
    // list without affecting special
    // characters
    static void reverse(Node head_ref,
                        int size)
    {
        Node current = head_ref;
 
        char []TEMP_ARR = new char[size];
 
        int i = 0;
 
        // Traverse the linked list
        // and insert linked list
        // elements to TEMP_ARR
        while (current != null)
        {
            // if the current data
            // is any alphabet than
            // store it in to TEMP_ARR
            if ((current.data >= 97 &&
                current.data <= 122) ||
                (current.data >= 65 &&
                current.data <= 90))
            {
                TEMP_ARR[i++] = current.data;
                current = current.next;
            }
 
            // else increase the node position
            else
                current = current.next;
        }
 
        current = head_ref;
 
        // Traverse the linked list again
        while (current != null)
        {
            // if current character is an
            // alphabet than replace the
            // current element in the linked
            // list with the last element
             // of the TEMP_ARR
            if ((current.data >= 97 &&
                current.data <= 122) ||
                (current.data >= 65 &&
                current.data <= 90))
            {
                current.data = TEMP_ARR[--i];
                current = current.next;
            }
 
            // else increase the node
            else
                current = current.next;
        }
    }
 
    // Function to push a node
    static Node push(Node head_ref,
                    char new_data)
    {
        /* allocate node */
        Node new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list
        off the new node */
        new_node.next = (head_ref);
 
        /* move the head to point
        to the new node */
        (head_ref) = new_node;
 
        return head_ref;
    }
 
    /* Function to print linked list */
    static void printList(Node head)
    {
        Node temp = head;
        while (temp != null)
        {
            Console.Write(temp.data);
            temp = temp.next;
        }
    }
 
    // Driver Code
    public static void Main(String []rags)
    {
        /* Start with the empty list */
        Node head = null;
 
        head = push(head, 's');
        head = push(head, '$');
        head = push(head, 'k');
        head = push(head, 'e');
        head = push(head, 'e');
        head = push(head, '@');
        head = push(head, '#');
        head = push(head, 'g');
        head = push(head, 'r');
        head = push(head, 'o');
        head = push(head, 'f');
        head = push(head, 's');
        head = push(head, '$');
        head = push(head, 'k');
        head = push(head, 'e');
        head = push(head, 'e');
        head = push(head, 'g');
 
        Console.Write( "Given linked list: ");
        printList(head);
 
        reverse(head, 13);
 
        Console.Write("\nReversed Linked list: ");
        printList(head);
    }
}
 
// This code has been contributed
// by 29AjayKumar
Javascript



<script>
 
// JavaScript program to reverse a
// linked list without affecting
// special characters
 
// Link list node
class Node
{
    constructor()
    {
        let data,next;
    }
}
 
// Function to reverse the linked
// list without affecting special
// characters
function reverse(head_ref,size)
{
    let current = head_ref;
  
  
let TEMP_ARR = new Array(size);
  
let i = 0;
  
// Traverse the linked list
// and insert linked list
// elements to TEMP_ARR
while (current != null)
{
    // if the current data
    // is any alphabet than
    // store it in to TEMP_ARR
    if ((current.data.charCodeAt(0) >= 97 &&
         current.data.charCodeAt(0) <= 122) ||
        (current.data.charCodeAt(0) >= 65 &&
         current.data.charCodeAt(0) <= 90))
    {
        TEMP_ARR[i++] = current.data;
        current = current.next;
    }
      
    // else increase the node position
    else
        current = current.next;
}
  
current = head_ref;
  
// Traverse the linked list again
while (current != null)
{
    // if current character is an
    // alphabet than replace the
    // current element in the linked
    // list with the last element
    // of the TEMP_ARR
    if ((current.data.charCodeAt(0) >= 97 &&
         current.data.charCodeAt(0) <= 122) ||
        (current.data.charCodeAt(0) >= 65 &&
         current.data.charCodeAt(0) <= 90))
    {
        current.data = TEMP_ARR[--i];
        current = current.next;
    }
      
    // else increase the node
    else
        current = current.next;
}
return head_ref;
     
}
// Function to push a node
function push(head_ref,new_data)
{
    /* allocate node */
    let new_node = new Node();
  
    /* put in the data */
    new_node.data = new_data;
  
    /* link the old list
       off the new node */
    new_node.next = (head_ref);
  
    /* move the head to point
       to the new node */
    (head_ref) = new_node;
      
    return head_ref;
}
 
/* Function to print linked list */
function printList(head)
{
    let temp = head;
    while (temp != null)
    {
        document.write(temp.data);
        temp = temp.next;
    }
}
 
// Driver Code
 
/* Start with the empty list */
let head = null;
 
head = push(head, 's');
head = push(head, '$');
head = push(head, 'k');
head = push(head, 'e');
head = push(head, 'e');
head = push(head, '@');
head = push(head, '#');
head = push(head, 'g');
head = push(head, 'r');
head = push(head, 'o');
head = push(head, 'f');
head = push(head, 's');
head = push(head, '$');
head = push(head, 'k');
head = push(head, 'e');
head = push(head, 'e');
head = push(head, 'g');
 
document.write( "Given linked list: ");
printList(head);
 
head=reverse(head, 13);
 
document.write("<br>Reversed Linked list: ");
printList(head);
     
     
// This code is contributed by unknown2108
 
</script>
Output
Given linked list: geek$sforg#@eek$s
Reversed Linked list: skee$grofs#@kee$g
Complexity Analysis:
  • Time Complexity : O(N), where N is the total number of nodes in the linked list.
  • Auxiliary Space: O(N) 

My Personal Notes
arrow_drop_up
Last Updated :
27 Mar, 2023
Like Article

Save Article

Similar Reads
1.
XOR linked list: Reverse last K nodes of a Linked List
2.
Reverse a Doubly Linked List without swapping nodes
3.
Append odd position nodes in reverse at the end of even positioned nodes in a Linked List
4.
Remove all special characters from a singly Linked List
5.
XOR Linked List - Reverse a Linked List in groups of given size
6.
Print reverse of a Linked List without actually reversing
7.
Print reverse of a Linked List without extra space and modifications
8.
C++ Program For Printing Reverse Of A Linked List Without Actually Reversing
9.
C Program For Printing Reverse Of A Linked List Without Actually Reversing
10.
Java Program For Printing Reverse Of A Linked List Without Actually Reversing
Related Tutorials
1.
Learn Data Structures with Javascript | DSA Tutorial
2.
Introduction to Max-Heap – Data Structure and Algorithm Tutorials
3.
Introduction to Set – Data Structure and Algorithm Tutorials
4.
Introduction to Map – Data Structure and Algorithm Tutorials
5.
What is Dijkstra’s Algorithm? | Introduction to Dijkstra's Shortest Path Algorithm
Next

Reverse a Linked List
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Shahnawaz_Ali
Shahnawaz_Ali
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue 
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox