Open In App

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

Last Updated : 26 Mar, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

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:

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<bits/stdc++.h>
using namespace std;

// 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 = 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 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 = new 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
        std::cout << 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);
}

// This code is contributed by ajaymakvana.
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);
}
Java 
// Java program for the above approach
import java.util.*;

// Structure of a node of XOR Linked List
class Node {
    // Stores data value of a node
    int data;
    // Stores XOR of previous pointer and next pointer
    Node npx;

    // Constructor
    Node(int data)
    {
        this.data = data;
        this.npx = null;
    }
}

// Class for the XOR Linked List
class XorLinkedList {

    Node head;

    XorLinkedList() { head = null; }

    // Function to insert a node with given value at given
    // position
    void insert(int value)
    {
        Node node = new Node(value);
        node.npx = head;
        head = node;
    }

    // Function to print elements of the XOR Linked List
    void printList()
    {
        // Stores XOR pointer in the current node
        Node curr = head;

        // Traverse XOR linked list
        while (curr != null) {
            // Print the current node
            System.out.print(curr.data + " ");

            // Update the curr pointer
            curr = curr.npx;
        }
    }

    // Function to reverse the linked list in the groups of
    // K
    Node reverseK(Node head, int K, int len)
    {
        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
            Node prev = null;
            // Stores the XOR pointer in the next node
            Node next = null;
            while (count < K && curr != null) {
                // Forward traversal
                next = curr.npx;
                // Update the curr.npx pointer
                curr.npx = prev;
                // Update the prev pointer
                prev = curr;
                // Update the curr pointer
                curr = next;

                // Count the number of nodes processed
                count++;
            }

            // // Add the prev with the head
            if (curr != null)
                head.npx = curr;

            // return prev
            return prev;
        }
    }

    // Function to reverse last K nodes of the given XOR
    // Linked List
    Node reverseLL(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);

        return head;
    }
}

public class GFG {
    // Driver Code
    public static void main(String[] args)
    {
        // Stores number of nodes
        int N = 6;
        // Given XOR Linked List
        XorLinkedList xorLinkedList = new XorLinkedList();
        xorLinkedList.insert(1);
        xorLinkedList.insert(3);
        xorLinkedList.insert(11);
        xorLinkedList.insert(8);
        xorLinkedList.insert(6);
        xorLinkedList.insert(7);
        int K = 3;
        xorLinkedList.head = xorLinkedList.reverseLL(
            xorLinkedList.head, N, K);
        // Print the final linked list
        xorLinkedList.printList();
    }
}

// This code is contributed by Susobhan Akhuli
JavaScript 
// JavaScript program for the above approach

// Structure of a node of XOR Linked List
class Node {
  constructor(data) {
    this.data = data;
    this.npx = null;
  }
}

// Class for the XOR Linked List
class XorLinkedList {
  constructor() {
    this.head = null;
  }

  // Function to insert a node with given value at given
  // position
  insert(value) {
    let node = new Node(value);
    node.npx = this.head;
    this.head = node;
  }

  // Function to print elements of the XOR Linked List
  printList() {
    // Stores XOR pointer in the current node
    let curr = this.head;
    let result = '';

    // Traverse XOR linked list
    while (curr != null) {
      // Add the current node data to the result string
      result += curr.data + " ";

      // Update the curr pointer
      curr = curr.npx;
    }

    // Print the result string
    console.log(result.trim());
  }

  // Function to reverse the linked list in the groups of
  // K
  reverseK(head, K, len) {
    let 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 {
      let count = 0;
      // Stores the XOR pointer in the previous Node
      let prev = null;
      // Stores the XOR pointer in the next node
      let next = null;
      while (count < K && curr != null) {
        // Forward traversal
        next = curr.npx;
        // Update the curr.npx pointer
        curr.npx = prev;
        // Update the prev pointer
        prev = curr;
        // Update the curr pointer
        curr = next;

        // Count the number of nodes processed
        count++;
      }

      // Add the prev with the head
      if (curr != null) head.npx = curr;

      // return prev
      return prev;
    }
  }

  // Function to reverse last K nodes of the given XOR
  // Linked List
  reverseLL(head, N, K) {
    // Reverse the given XOR LL
    head = this.reverseK(head, N, N);
    // Reverse the first K nodes of the XOR LL
    head = this.reverseK(head, K, N);
    // Reverse the given XOR LL
    head = this.reverseK(head, N, N);

    return head;
  }
}

// Driver Code
let N = 6;
// Given XOR Linked List
let xorLinkedList = new XorLinkedList();
xorLinkedList.insert(1);
xorLinkedList.insert(3);
xorLinkedList.insert(11);
xorLinkedList.insert(8);
xorLinkedList.insert(6);
xorLinkedList.insert(7);
let K = 3;
xorLinkedList.head = xorLinkedList.reverseLL(
  xorLinkedList.head,
  N,
  K
);
// Print the final linked list
xorLinkedList.printList();
Python3 
# Python program for the above approach

# Structure of a node of XOR Linked List
class Node:
    # Constructor
    def __init__(self, data):
        # Stores data value of a node
        self.data = data
        # Stores XOR of previous pointer and next pointer
        self.npx = None

# Class for the XOR Linked List
class XorLinkedList:
    # Constructor
    def __init__(self):
        self.head = None

    # Function to insert a node with given value at given position
    def insert(self, value):
        node = Node(value)
        node.npx = self.head
        self.head = node

    # Function to print elements of the XOR Linked List
    def printList(self):
        # Stores XOR pointer in the current node
        curr = self.head
        # Traverse XOR linked list
        while curr != None:
            # Print the current node
            print(curr.data, end=" ")
            # Update the curr pointer
            curr = curr.npx

    # Function to reverse the linked list in the groups of K
    def reverseK(self, head, K, length):
        curr = head
        # If head is NULL
        if curr == None:
            return None
        # If the size of XOR linked list is less than K
        elif length < K:
            return head
        else:
            count = 0
            # Stores the XOR pointer in the previous Node
            prev = None
            # Stores the XOR pointer in the next node
            next = None
            while count < K and curr != None:
                # Forward traversal
                next = curr.npx
                # Update the curr.npx pointer
                curr.npx = prev
                # Update the prev pointer
                prev = curr
                # Update the curr pointer
                curr = next
                # Count the number of nodes processed
                count += 1
            # Add the prev with the head
            if curr != None:
                head.npx = curr
            # return prev
            return prev

    # Function to reverse last K nodes of the given XOR Linked List
    def reverseLL(self, head, N, K):
        # Reverse the given XOR LL
        head = self.reverseK(head, N, N)
        # Reverse the first K nodes of the XOR LL
        head = self.reverseK(head, K, N)
        # Reverse the given XOR LL
        head = self.reverseK(head, N, N)
        return head

# Driver Code
if __name__ == "__main__":
    # Stores number of nodes
    N = 6
    # Given XOR Linked List
    xorLinkedList = XorLinkedList()
    xorLinkedList.insert(1)
    xorLinkedList.insert(3)
    xorLinkedList.insert(11)
    xorLinkedList.insert(8)
    xorLinkedList.insert(6)
    xorLinkedList.insert(7)
    K = 3
    xorLinkedList.head = xorLinkedList.reverseLL(xorLinkedList.head, N, K)
    # Print the final linked list
    xorLinkedList.printList()

# This code is contributed by Susobhan Akhuli

Output
7 6 8 1 3 11

Time Complexity: O(N), as we are using a loop to traverse N times, where N is the length of the linked list.
Auxiliary Space: O(1), as we are not using any extra space.



Like Article
Suggest improvement
Next
XOR Linked List: Remove last node of the Linked List
Share your thoughts in the comments

Similar Reads

Print the last k nodes of the linked list in reverse order | Recursive approach
Print the last k nodes of the linked list in reverse order | Iterative Approaches
Append odd position nodes in reverse at the end of even positioned nodes in a Linked List
XOR Linked List - Reverse a Linked List in groups of given size
XOR Linked List: Remove last node of the Linked List
Count of subarrays in range [L, R] having XOR + 1 equal to XOR (XOR) 1 for M queries
Reverse alternate K nodes in a Singly Linked List
Reverse the order of all nodes at even position in given Linked List
Reverse a Doubly Linked List without swapping nodes
Reverse nodes of a linked list without affecting the special characters

D
debarpan_bose_chowdhury
Article Tags :
Practice Tags :
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