Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

XOR linked list: Reverse last K nodes of a Linked List

  • Last Updated : 05 Mar, 2021

Given a XOR Linked List and a positive integer K, the task is to reverse the last K nodes in the given XOR linked list.

Examples:

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.

Input: LL: 7 <–> 6 <–> 8 <–> 11 <–> 3 <–> 1, K = 3
Output: 7<–>6<–>8<–>1<–>3<–>11



Input: LL: 7 <–> 6 <–> 8 <–> 11 <–> 3 <–> 1 <–> 2 <–> 0, K = 5
Output: 7<–>6<–>8<–>0<–>2<–>1<–>3<–>11

Approach: Follow the steps below to solve the given problem:

Below is the implementation of the above approach:

C




// C program for the above approach
  
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
  
// Structure of a node
// of 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 calculate
// Bitwise XOR of the 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)
{
    // If XOR linked list is empty
    if (*head == NULL) {
  
        // 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 the XOR linked
    // list is not empty
    else {
  
        // Stores the address
        // of the current node
        struct Node* curr = *head;
  
        // Stores the address
        // of the previous node
        struct Node* prev = NULL;
  
        // Initialize a new Node
        struct Node* node
            = (struct Node*)malloc(
                sizeof(struct Node));
  
        // Update address of current node
        curr->nxp = XOR(node,
                        XOR(
                            NULL, curr->nxp));
  
        // Update address of the new node
        node->nxp = XOR(NULL, curr);
  
        // Update the head node
        *head = node;
  
        // Update the data
        // value of current node
        node->data = value;
    }
    return *head;
}
  
// Function to print elements
// of the XOR Linked List
void printList(struct Node** head)
{
    // Stores XOR pointer
    // in the current node
    struct Node* curr = *head;
  
    // Stores XOR pointer
    // in the previous Node
    struct Node* prev = NULL;
  
    // Stores XOR pointer in the
    // next node
    struct Node* next;
  
    // Traverse XOR linked list
    while (curr != NULL) {
  
        // Print the current node
        printf("%d ", curr->data);
  
        // Forward traversal
        next = XOR(prev, curr->nxp);
  
        // Update the prev pointer
        prev = curr;
  
        // Update the curr pointer
        curr = next;
    }
}
  
// Function to reverse the linked
// list in the groups of K
struct Node* reverseK(struct Node** head,
                      int K, int len)
{
    struct Node* curr = *head;
  
    // If head is NULL
    if (curr == NULL)
        return NULL;
  
    // If the size of XOR linked
    // list is less than K
    else if (len < K)
        return *head;
    else {
  
        int count = 0;
  
        // Stores the XOR pointer
        // in the previous Node
        struct Node* prev = NULL;
  
        // Stores the XOR pointer
        // in the next node
        struct Node* next;
  
        while (count < K) {
  
            // Forward traversal
            next = XOR(prev, curr->nxp);
  
            // Update the prev pointer
            prev = curr;
  
            // Update the curr pointer
            curr = next;
  
            // Count the number of
            // nodes processed
            count++;
        }
  
        // Remove the prev node
        // from the next node
        prev->nxp = XOR(NULL,
                        XOR(prev->nxp,
                            curr));
  
        // Add the head pointer with prev
        (*head)->nxp = XOR(XOR(NULL,
                               (*head)->nxp),
                           curr);
  
        // Add the prev with the head
        if (curr != NULL)
            curr->nxp = XOR(XOR(curr->nxp,
                                prev),
                            *head);
        return prev;
    }
}
  
// Function to reverse last K nodes
// of the given XOR Linked List
void reverseLL(struct Node* head,
               int N, int K)
{
  
    // Reverse the given XOR LL
    head = reverseK(&head, N, N);
  
    // Reverse the first K nodes of
    // the XOR LL
    head = reverseK(&head, K, N);
  
    // Reverse the given XOR LL
    head = reverseK(&head, N, N);
  
    // Print the final linked list
    printList(&head);
}
  
// Driver Code
int main()
{
    // Stores number of nodes
    int N = 6;
  
    // Given XOR Linked List
  
    struct Node* head = NULL;
    insert(&head, 1);
    insert(&head, 3);
    insert(&head, 11);
    insert(&head, 8);
    insert(&head, 6);
    insert(&head, 7);
  
    int K = 3;
  
    reverseLL(head, N, K);
  
    return (0);
}
Output:
7 6 8 1 3 11

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :