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)