XOR Linked List – Find the middle node

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)