Open In App

XOR Linked List - Find the middle node

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an XOR linked list, the task is to find the middle node of the given XOR linked list.

Examples:

Input: 4 –> 7 –> 5 
Output: 7 
Explanation: 
The middle node of the given XOR list is 7.

Input: 4 –> 7 –> 5 –> 1 
Output: 7 5 
Explanation: 
The two middle nodes of the XOR linked list with even number of nodes are 7 and 5. 
 

Approach: Follow the steps below to solve the problem:

  • Traverse to (Length / 2)th node of the Linked List.
  • If the number of nodes is found to be odd, then print (Length + 1) / 2 th node as the only middle node.
  • If the number of nodes is found to be even, then print both Length / 2 th node and (Length / 2) + 1 th node as the middle nodes.

Below is the implementation of the above approach:

C++ 
// C++ program to implement the above approach
#include <bits/stdc++.h>
#include <inttypes.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)
{

    // 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 current node
        struct Node* curr = *head;

        // Stores the address
        // of previous node
        struct Node* prev = NULL;

        // 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;
    }
    return *head;
}

// Function to print the middle node
int printMiddle(struct Node** head, int len)
{
    int count = 0;

    // 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;

    int middle = (int)len / 2;

    // Traverse XOR linked list
    while (count != middle) {

        // Forward traversal
        next = XOR(prev, curr->nxp);

        // Update prev
        prev = curr;

        // Update curr
        curr = next;

        count++;
    }

    // If the length of the
    // linked list is odd
    if (len & 1) {
        cout << curr->data << " ";
    }

    // If the length of the
    // linked list is even
    else {
        cout << prev->data << " " << curr->data << " ";
    }
}

// Driver Code
int main()
{
    /* Create following XOR Linked List
    head --> 4 –> 7 –> 5 */
    struct Node* head = NULL;
    insert(&head, 4);
    insert(&head, 7);
    insert(&head, 5);

    printMiddle(&head, 3);

    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)
{

    // 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 current node
        struct Node* curr = *head;

        // Stores the address
        // of previous node
        struct Node* prev = NULL;

        // 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;
    }
    return *head;
}

// Function to print the middle node
int printMiddle(struct Node** head, int len)
{
    int count = 0;

    // 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;

    int middle = (int)len / 2;

    // Traverse XOR linked list
    while (count != middle) {

        // Forward traversal
        next = XOR(prev, curr->nxp);

        // Update prev
        prev = curr;

        // Update curr
        curr = next;

        count++;
    }

    // If the length of the
    // linked list is odd
    if (len & 1) {
        printf("%d", curr->data);
    }

    // If the length of the
    // linked list is even
    else {
        printf("%d %d", prev->data,
               curr->data);
    }
}

// Driver Code
int main()
{
    /* Create following XOR Linked List
    head --> 4 –> 7 –> 5 */
    struct Node* head = NULL;
    insert(&head, 4);
    insert(&head, 7);
    insert(&head, 5);

    printMiddle(&head, 3);

    return (0);

}
Java 
import java.util.ArrayList;

// Structure of a node in XOR linked list
class Node {
    int value;
    int npx; // XOR of next and previous node addresses

    public Node(int value) {
        this.value = value;
        this.npx = 0;
    }
}

// XOR Linked List class
class XorLinkedList {
    Node head; // head of the XOR linked list
    Node tail; // tail of the XOR linked list
    ArrayList<Node> nodes; // list to keep track of all nodes in the XOR linked list

    // Constructor
    public XorLinkedList() {
        this.head = null;
        this.tail = null;
        this.nodes = new ArrayList<>();
    }

    // Function to insert a node with the given value
    void insert(int value) {
        // Initialize a new Node
        Node node = new Node(value);

        // Check if the XOR linked list is empty
        if (head == null) {
            // Update pointer of head node
            head = node;
            // Update pointer of tail node
            tail = node;
        } else {
            // Update curr node address
            head.npx = System.identityHashCode(node) ^ head.npx;
            // Update new node address
            node.npx = System.identityHashCode(head);
            // Update head
            head = node;
        }

        // Add the node to the list
        nodes.add(node);
    }

    // Method to get the length of the linked list
    int length() {
        if (!isEmpty()) {
            int prevId = 0;
            Node node = head;
            int nextId = 1;
            int count = 1;

            while (nextId != 0) {
                nextId = prevId ^ node.npx;

                if (nextId != 0) {
                    prevId = System.identityHashCode(node);
                    node = getTypeCastedNode(nextId);
                    count++;
                } else {
                    return count;
                }
            }
        }
        return 0;
    }

    // Function to print the middle element(s) of the XOR Linked List
    void printMiddle(int length) {
        if (head != null) {
            int prevId = 0;
            Node node = head;
            int nextId = 1;

            // Traverse XOR linked list
            int middle = length / 2;
            int count = 0;
            Node prev = null;

            while (count != middle) {
                count++;

                // Forward traversal
                nextId = prevId ^ node.npx;

                if (nextId != 0) {
                    // Update prev
                    prevId = System.identityHashCode(node);

                    // Update curr
                    prev = node;
                    node = getTypeCastedNode(nextId);
                } else {
                    return;
                }
            }

            if (length % 2 != 0) {
                System.out.print(node.value + " ");
            } else {
                System.out.print(prev.value + " " + node.value + " ");
            }
        }
    }

    // Method to check if the linked list is empty
    boolean isEmpty() {
        return head == null;
    }

    // Method to return a new instance of type
    Node getTypeCastedNode(int id) {
        for (Node n : nodes) {
            if (System.identityHashCode(n) == id) {
                return n;
            }
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        // Create XOR Linked List: head --> 4 <--> 7 <--> 5
        XorLinkedList xorLinkedList = new XorLinkedList();
        xorLinkedList.insert(4);
        xorLinkedList.insert(7);
        xorLinkedList.insert(5);

        // Reverse the XOR Linked List to give: head --> 5 <--> 7 <--> 4
        int length = xorLinkedList.length();
        xorLinkedList.printMiddle(length);
    }
}
Python3 
# C program to implement
# the above approach
import ctypes


# Structure of a node in XOR linked list
class Node:
    
    def __init__(self, value):
        self.value = value
        self.npx = 0


# create linked list class
class XorLinkedList:
 
    # constructor
    def __init__(self):
        self.head = None
        self.tail = None
        self.__nodes = []
        
    
    # Function to insert a node with given value at given position
    def insert(self, value):
        
        # Initialize a new Node
        node = Node(value)
        
        # Check If XOR linked list is empty
        if self.head is None:
            
            # Update pointer of head node
            self.head = node
            
            # Update pointer of tail node
            self.tail = node
            
        else:
            
            # Update curr node address
            self.head.npx = id(node) ^ self.head.npx
            
            # Update new node address
            node.npx = id(self.head)
            
            # Update head
            self.head = node
            
        # push node
        self.__nodes.append(node)
        
        
    # method to get length of linked list
    def Length(self):
        if not self.isEmpty():
            prev_id = 0
            node = self.head
            next_id = 1
            count = 1
            while next_id:
                next_id = prev_id ^ node.npx
                if next_id:
                    prev_id = id(node)
                    node = self.__type_cast(next_id)
                    count += 1
                else:
                    return count
        else:
            return 0
        
    # Function to print elements of the XOR Linked List
    def printMiddle(self, length):
 
        if self.head != None:
            prev_id = 0
            node = self.head
            next_id = 1
            
            # Traverse XOR linked list
            middle = length // 2
            count = 0
            prev = None
            
            while count != middle:
                
                count = count + 1
                
                # Forward traversal
                next_id = prev_id ^ node.npx
                
                if next_id:
                    
                    # Update prev
                    prev_id = id(node)
                    
                    # Update curr
                    prev = node
                    node = self.__type_cast(next_id)

                else:
                    return
                
            if length % 2 != 0: 
                print(node.value, end = ' ')
            else:
                print(prev.value, node.value, end = ' ')

                
    # method to check if the linked list is empty or not
    def isEmpty(self):
        if self.head is None:
            return True
        return False
    
    # method to return a new instance of type
    def __type_cast(self, id):
        return ctypes.cast(id, ctypes.py_object).value
    

# Create following XOR Linked List
# head-->40<-->30<-->20<-->10 
head = XorLinkedList()
head.insert(4)
head.insert(7)
head.insert(5)


# Reverse the XOR Linked List to give
# head-->10<-->20<-->30<-->40 
length = head.Length()
head.printMiddle(length)


# This code is contributed by Nidhi goel.
C# 
// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

// Structure of a node in XOR linked list
public class Node {
    public int value;
    public int
        npx; // XOR of next and previous node addresses

    public Node(int value)
    {
        this.value = value;
        this.npx = 0;
    }
}

// XOR Linked List class
public class XorLinkedList {
    Node head; // head of the XOR linked list
    List<Node> nodes; // list to keep track of all nodes in
                      // the XOR linked list

    // Constructor
    public XorLinkedList()
    {
        this.head = null;
        this.nodes = new List<Node>();
    }

    // Function to insert a node with the given value
    public void Insert(int value)
    {
        // Initialize a new Node
        Node node = new Node(value);

        // Check if the XOR linked list is empty
        if (head == null) {
            // Update pointer of head node
            head = node;
        }
        else {
            // Update curr node address
            head.npx = RuntimeHelpers.GetHashCode(node)
                       ^ head.npx;
            // Update new node address
            node.npx = RuntimeHelpers.GetHashCode(head);
            // Update head
            head = node;
        }

        // Add the node to the list
        nodes.Add(node);
    }

    // Method to get the length of the linked list
    public int Length()
    {
        if (!IsEmpty()) {
            int prevId = 0;
            Node node = head;
            int nextId = 1;
            int count = 1;

            while (nextId != 0) {
                nextId = prevId ^ node.npx;

                if (nextId != 0) {
                    prevId
                        = RuntimeHelpers.GetHashCode(node);
                    node = GetTypeCastedNode(nextId);
                    count++;
                }
                else {
                    return count;
                }
            }
        }
        return 0;
    }

    // Function to print the middle element(s) of the XOR
    // Linked List
    public void PrintMiddle(int length)
    {
        if (head != null) {
            int prevId = 0;
            Node node = head;
            int nextId = 1;

            // Traverse XOR linked list
            int middle = length / 2;
            int count = 0;
            Node prev = null;

            while (count != middle) {
                count++;

                // Forward traversal
                nextId = prevId ^ node.npx;

                if (nextId != 0) {
                    // Update prev
                    prevId
                        = RuntimeHelpers.GetHashCode(node);

                    // Update curr
                    prev = node;
                    node = GetTypeCastedNode(nextId);
                }
                else {
                    return;
                }
            }

            if (length % 2 != 0) {
                Console.Write(node.value + " ");
            }
            else {
                Console.Write(prev.value + " " + node.value
                              + " ");
            }
        }
    }

    // Method to check if the linked list is empty
    public bool IsEmpty() { return head == null; }

    // Method to return a new instance of type
    public Node GetTypeCastedNode(int id)
    {
        foreach(Node n in nodes)
        {
            if (RuntimeHelpers.GetHashCode(n) == id) {
                return n;
            }
        }
        return null;
    }
}

public class GFG {
    public static void Main(string[] args)
    {
        // Create XOR Linked List: head --> 4 <--> 7 <--> 5
        XorLinkedList xorLinkedList = new XorLinkedList();
        xorLinkedList.Insert(4);
        xorLinkedList.Insert(7);
        xorLinkedList.Insert(5);

        // Reverse the XOR Linked List to give: head --> 5
        // <--> 7 <--> 4
        int length = xorLinkedList.Length();
        xorLinkedList.PrintMiddle(length);
    }
}

// This code is contributed by Susobhan Akhuli
JavaScript 
// JavaScript program to implement the above approach
class Node {
  constructor(value) {
    this.value = value;
    this.npx = 0;
  }
}

// create linked list class
class XorLinkedList {
  // constructor
  constructor() {
    this.head = null;
    this.tail = null;
    this.__nodes = [];
  }

  // Function to insert a node with given value at given position
  insert(value) {
    // Initialize a new Node
    const node = new Node(value);

    // Check If XOR linked list is empty
    if (this.head === null) {
      // Update pointer of head node
      this.head = node;
      // Update pointer of tail node
      this.tail = node;
    } else {
      // Update curr node address
      this.head.npx = this.__getId(node) ^ this.head.npx;
      // Update new node address
      node.npx = this.__getId(this.head);
      // Update head
      this.head = node;
    }
    // push node
    this.__nodes.push(node);
  }

  // method to get length of linked list
  length() {
    if (!this.isEmpty()) {
      let prevId = 0;
      let node = this.head;
      let nextId = 1;
      let count = 1;
      while (nextId) {
        nextId = prevId ^ node.npx;
        if (nextId) {
          prevId = this.__getId(node);
          node = this.__typeCast(nextId);
          count += 1;
        } else {
          return count;
        }
      }
    } else {
      return 0;
    }
  }

  // Function to print elements of the XOR Linked List
  printMiddle(length) {
    if (this.head !== null) {
      let prevId = 0;
      let node = this.head;
      let nextId = 1;
      // Traverse XOR linked list
      const middle = Math.floor(length / 2);
      let count = 0;
      let prev = null;
      while (count !== middle) {
        count = count + 1;
        // Forward traversal
        nextId = prevId ^ node.npx;
        if (nextId) {
          // Update prev
          prevId = this.__getId(node);
          // Update curr
          prev = node;
          node = this.__typeCast(nextId);
        } else {
          return;
        }
      }
      if (length % 2 !== 0) {
        console.log(node.value);
      } else {
        console.log(prev.value, node.value);
      }
    }
  }

  // method to check if the linked list is empty or not
  isEmpty() {
    if (this.head === null) {
      return true;
    }
    return false;
  }

  // method to return a new instance of type
  __typeCast(id) {
    return ctypes.cast(id, ctypes.py_object).value;
  }

  // method to get the unique ID of an object
  __getId(obj) {
    return obj && obj.__unique_id__;
  }
}

// Create following XOR Linked List
// head-->40<-->30<-->20<-->10
const head = new XorLinkedList();
head.insert(4);
head.insert(5);
head.insert(7);


// Reverse the XOR Linked List to give
// head-->10<-->20<-->30<-->40
const length = head.length();
head.printMiddle(length);

//this is generated by chetanbargal

Output
7

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


 


Next Article
Analysis of Algorithms

D
debarpan_bose_chowdhury
Improve
Article Tags :

Similar Reads

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