Reverse nodes of a linked list without affecting the special characters

Last Updated : 27 Mar, 2023

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:

Take a temporary array, TEMP_ARR.
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
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# 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)

Analysis of Algorithms

Shahnawaz_Ali

Improve

Article Tags :

Practice Tags :

Arrays

Reverse nodes of a linked list without affecting the special characters

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?