Skip to content
Related Articles

Related Articles

Improve Article

XOR Linked List – Insert an element at a specific position

  • Difficulty Level : Hard
  • Last Updated : 13 Oct, 2021
Geek Week

Given a XOR linked list and two integers position and value, the task is to insert a node containing value as the positionth node of the XOR Linked List.

Examples:

Input: 4<–>7<–>9<–>7, position = 3, value = 6 
Output: 4<–>7<–>6<–>9<–>7
Explanation: 
Inserting a node at the 3rd position with value 6 modifies the given XOR Linked List to 4<–>7<–>6<–>9<–>7.

Input: 4<–>7<–>9<–>7, position=6, value=6 
Output: Invalid Position 
Explanation: Since the given list consists of only 4 elements, 6th position is an invalid position in the given list.

Approach: Follow the steps below to solve the problem:



  • Initialize a variable, say ctr to keep a count of the nodes traversed in the given XOR linked list.
  • Traverse the given XOR linked list. For every node of the XOR Linked List, check if the position of the current node in equal to position or not. If found to be true, then insert the node in the given XOR linked list.
  • Otherwise, increment ctr by 1.
  • If the entire list is traversed and positionth node was not obtained, then print “Invalid Position”.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include<bits/stdc++.h>
using namespace std;
 
// Structure of a node
// in XOR linked list
struct Node {
 
    // Stores data value
    // of a node
    int data;
 
    // Stores XOR of previous
    // pointer and next pointer
    struct Node* nxp;
};
 
// Function to find the XOR of two nodes
struct Node* XOR(struct Node* a,
                 struct Node* b)
{
    return (struct Node*)((uintptr_t)(a)^ (uintptr_t)(b));
}
 
// Function to insert a node with
// given value at given position
struct Node* insert(struct Node** head,
                    int value, int position)
{
    // If XOR linked list is empty
    if (*head == NULL) {
 
        // If given position
        // is equal to 1
        if (position == 1) {
 
            // Initialize a new Node
            struct Node* node
                = new Node();
 
            // Stores data value in
            // the node
            node->data = value;
 
            // Stores XOR of previous
            // and next pointer
            node->nxp = XOR(NULL, NULL);
 
            // Update pointer of head node
            *head = node;
        }
 
        // If required position was not found
        else {
            cout << "Invalid Position\n";
        }
    }
 
    // If the XOR linked list
    // is not empty
    else {
 
        // Stores position of a node
        // in the XOR linked list
        int Pos = 1;
 
        // Stores the address
        // of current node
        struct Node* curr = *head;
 
        // Stores the address
        // of previous node
        struct Node* prev = NULL;
 
        // Stores the XOR of next
        // node and previous node
        struct Node* next
            = XOR(prev, curr->nxp);
 
        // Traverse the XOR linked list
        while (next != NULL && Pos < position - 1) {
 
            // Update prev
            prev = curr;
 
            // Update curr
            curr = next;
 
            // Update next
            next = XOR(prev, curr->nxp);
 
            // Update Pos
            Pos++;
        }
 
        // If the position of the current
        // node is equal to the given position
        if (Pos == position - 1) {
 
            // Initialize a new Node
            struct Node* node
                = new Node();
 
            // Stores pointer to previous Node
            // as (prev ^ next ^ next) = prev
            struct Node* temp
                = XOR(curr->nxp, next);
 
            // Stores XOR of prev and new node
            curr->nxp = XOR(temp, node);
 
            // Connecting new node with next
            if (next != NULL) {
 
                // Update pointer of next
                next->nxp = XOR(node,
                                XOR(next->nxp, curr));
            }
 
            // Connect node with curr and
            // next curr<--node-->next
            node->nxp = XOR(curr, next);
            node->data = value;
        }
 
        // Insertion node at beginning
        else if (position == 1) {
 
            // Initialize a new Node
            struct Node* node
                = new Node();
 
            // Update curr node address
            curr->nxp = XOR(node,
                            XOR(NULL, curr->nxp));
 
            // Update new node address
            node->nxp = XOR(NULL, curr);
 
            // Update head
            *head = node;
 
            // Update data value of
            // current node
            node->data = value;
        }
        else {
            cout << "Invalid Position\n";
        }
    }
    return *head;
}
 
// Function to print elements of
// the XOR Linked List
void printList(struct Node** head)
{
    // Stores XOR pointer
    // in current node
    struct Node* curr = *head;
 
    // Stores XOR pointer of
    // in previous Node
    struct Node* prev = NULL;
 
    // Stores XOR pointer of
    // in next node
    struct Node* next;
 
    // Traverse XOR linked list
    while (curr != NULL) {
 
        // Print current node
       cout << curr->data << " ";
 
        // Forward traversal
        next = XOR(prev, curr->nxp);
 
        // Update prev
        prev = curr;
 
        // Update curr
        curr = next;
    }
}
 
// Driver Code
int main()
{
    /* Create following XOR Linked List
    head-->20<-->40<-->10<-->30 */
    struct Node* head = NULL;
    insert(&head, 10, 1);
    insert(&head, 20, 1);
    insert(&head, 30, 3);
    insert(&head, 40, 2);
 
    // Print the new list
    printList(&head);
 
    return 0;
}

C




// C++ program to implement
// the above approach
 
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
 
// Structure of a node
// in XOR linked list
struct Node {
 
    // Stores data value
    // of a node
    int data;
 
    // Stores XOR of previous
    // pointer and next pointer
    struct Node* nxp;
};
 
// Function to find the XOR of two nodes
struct Node* XOR(struct Node* a,
                 struct Node* b)
{
    return (struct Node*)((uintptr_t)(a)
                          ^ (uintptr_t)(b));
}
 
// Function to insert a node with
// given value at given position
struct Node* insert(struct Node** head,
                    int value, int position)
{
    // If XOR linked list is empty
    if (*head == NULL) {
 
        // If given position
        // is equal to 1
        if (position == 1) {
 
            // Initialize a new Node
            struct Node* node
                = (struct Node*)malloc(
                    sizeof(struct Node));
 
            // Stores data value in
            // the node
            node->data = value;
 
            // Stores XOR of previous
            // and next pointer
            node->nxp = XOR(NULL, NULL);
 
            // Update pointer of head node
            *head = node;
        }
 
        // If required position was not found
        else {
            printf("Invalid Position\n");
        }
    }
 
    // If the XOR linked list
    // is not empty
    else {
 
        // Stores position of a node
        // in the XOR linked list
        int Pos = 1;
 
        // Stores the address
        // of current node
        struct Node* curr = *head;
 
        // Stores the address
        // of previous node
        struct Node* prev = NULL;
 
        // Stores the XOR of next
        // node and previous node
        struct Node* next
            = XOR(prev, curr->nxp);
 
        // Traverse the XOR linked list
        while (next != NULL && Pos < position - 1) {
 
            // Update prev
            prev = curr;
 
            // Update curr
            curr = next;
 
            // Update next
            next = XOR(prev, curr->nxp);
 
            // Update Pos
            Pos++;
        }
 
        // If the position of the current
        // node is equal to the given position
        if (Pos == position - 1) {
 
            // Initialize a new Node
            struct Node* node
                = (struct Node*)malloc(
                    sizeof(struct Node));
 
            // Stores pointer to previous Node
            // as (prev ^ next ^ next) = prev
            struct Node* temp
                = XOR(curr->nxp, next);
 
            // Stores XOR of prev and new node
            curr->nxp = XOR(temp, node);
 
            // Connecting new node with next
            if (next != NULL) {
 
                // Update pointer of next
                next->nxp = XOR(node,
                                XOR(next->nxp, curr));
            }
 
            // Connect node with curr and
            // next curr<--node-->next
            node->nxp = XOR(curr, next);
            node->data = value;
        }
 
        // Insertion node at beginning
        else if (position == 1) {
 
            // Initialize a new Node
            struct Node* node
                = (struct Node*)malloc(
                    sizeof(struct Node));
 
            // Update curr node address
            curr->nxp = XOR(node,
                            XOR(NULL, curr->nxp));
 
            // Update new node address
            node->nxp = XOR(NULL, curr);
 
            // Update head
            *head = node;
 
            // Update data value of
            // current node
            node->data = value;
        }
        else {
            printf("Invalid Position\n");
        }
    }
    return *head;
}
 
// Function to print elements of
// the XOR Linked List
void printList(struct Node** head)
{
    // Stores XOR pointer
    // in current node
    struct Node* curr = *head;
 
    // Stores XOR pointer of
    // in previous Node
    struct Node* prev = NULL;
 
    // Stores XOR pointer of
    // in next node
    struct Node* next;
 
    // Traverse XOR linked list
    while (curr != NULL) {
 
        // Print current node
        printf("%d ", curr->data);
 
        // Forward traversal
        next = XOR(prev, curr->nxp);
 
        // Update prev
        prev = curr;
 
        // Update curr
        curr = next;
    }
}
 
// Driver Code
int main()
{
    /* Create following XOR Linked List
    head-->20<-->40<-->10<-->30 */
    struct Node* head = NULL;
    insert(&head, 10, 1);
    insert(&head, 20, 1);
    insert(&head, 30, 3);
    insert(&head, 40, 2);
 
    // Print the new list
    printList(&head);
 
    return (0);
}
Output: 
20 40 10 30

 

Time Complexity: O(N)
Auxiliary Space: O(1)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :