Given a linked list containing N nodes of binary numbers, the task is to check whether it is possible to rearrange the linked list in such a way that value of XOR between element at ith Node and N+1−ith node is the same for all 1 ≤ i ≤ N. Print Yes, if the Linked List can be rearranged, or else print No.
Examples:
Input: LL = 0 -> 0 -> 1
Output: Yes
Explanation : 001 can be rearranged to form 010 which means 0 ⊕ 0 = 0 and 1 ⊕ 1 =0 are same . So output is 1.Input : 0001 (0->0->0->1)
Output : No
Explanation : 0001 can not be rearranged . So output is 0.
Approach: The idea is based on the linked list traversal, based on following observations:
Case 1: If size of linked linked list is odd, then it is always possible. So directly return Yes.
For example:
- 00001 can be rearranged as 00100
- 00011 can be rearranged as 10001
- 00111 can be rearranged as 10101
- 01111 can be rearranged as 11011
Case 2: If size of linked linked list is even, Count the number of 1 present in linked list. If number of 1s present in linked list is equal to the half the size of linked list, then return Yes, because rearrangement will be always possible.
For example:
- 0011
number of 1’s = half of size of linked list
so it can be rearranged as 1001- 001101
number of 1’s = half of size of linked list
so it can be rearranged as 010101Case 3: if number of 1’s present in our linked list is even, then also it is always possible. So directly return Yes.
For example:
- 000011 can be rearranged as 100001 or 001100
- 011 can be rearranged as 101
Case 4: if above all conditions are false, then return No.
For example:
- 011111 cannot be rearranged
- 000001 cannot be rearranged
Follow the below steps to implement the above approach:
- Calculate the size of linked list.
- If size is odd then return 1 because it is always possible to rearrange linked list as discuss above.
- If size is even, count the number of node consist value 1.
- If count of number of node consist value 1 is half of the size of linked list then return 1.
- If size is even and count of number of node consist value 1 is even then return 1.
- If all the above condition is fail to execute then return 0.
Below is the implementation of the above approach:
// C++ code for the above approach: #include <iostream> using namespace std;
// Node Class class Node {
public :
int data;
Node* next;
}; // Function to append the node void append(Node** head_ref, int new_data)
{ Node* new_node = new Node();
Node* last = *head_ref;
new_node->data = new_data;
new_node->next = NULL;
if (*head_ref == NULL) {
*head_ref = new_node;
return ;
}
while (last->next != NULL) {
last = last->next;
}
last->next = new_node;
return ;
} // Count the size of linked list int CountSize(Node* head)
{ Node* temp = head;
int count = 0;
while (temp != NULL) {
count++;
temp = temp->next;
}
return count;
} // Bool function to check // is it possible to make // such linked list bool isPossible(Node* head)
{ // count size of linked list
int n = CountSize(head);
// if n is odd
if (n % 2 != 0) {
return 1;
}
else {
int o = 0;
Node* temp = head;
while (temp != NULL) {
if (temp->data == 1) {
o++;
}
temp = temp->next;
}
if (o == (n / 2)) {
return 1;
}
else if (o % 2 == 0) {
return 1;
}
else {
return 0;
}
}
} // Driver Code int main()
{ Node* head = NULL;
append(&head, 0);
append(&head, 0);
append(&head, 1);
append(&head, 1);
cout << (isPossible(head) == 1
? "Yes"
: "No" )
<< endl;
} |
// Java code to implement the approach import java.io.*;
import java.util.*;
class GFG {
// Structure of a binary tree node
public static class Node {
int data;
Node next;
Node( int data)
{
this .data = data;
this .next = null ;
}
}
// Count the size of linked list
static int CountSize(Node head) {
Node temp = head;
int count = 0 ;
while (temp != null ) {
count++;
temp = temp.next;
}
return count;
}
// Bool function to check
// is it possible to make
// such linked list
static int isPossible(Node head) {
// count size of linked list
int n = CountSize(head);
// if n is odd
if (n % 2 != 0 ) {
return 1 ;
}
else {
int o = 0 ;
Node temp = head;
while (temp != null ) {
if (temp.data == 1 ) {
o++;
}
temp = temp.next;
}
if (o == Math.floor(n / 2 )) {
return 1 ;
}
else if (o % 2 == 0 ) {
return 1 ;
}
else {
return 0 ;
}
}
}
// Driver Code
public static void main(String[] args)
{
Node head = new Node( 1 );
head.next = new Node( 1 );
head.next.next = new Node( 0 );
head.next.next.next = new Node( 0 );
System.out.println((isPossible(head) == 1
? "Yes"
: "No" ));
}
} // This code is contributed by jana_sayantan. |
# Python code for the above approach # Node Class class Node:
def __init__( self ,d):
self .data = d
self . next = None
# Count the size of linked list def CountSize(head):
temp = head
count = 0
while (temp ! = None ):
count + = 1
temp = temp. next
return count
# Bool function to check # is it possible to make # such linked list def isPossible(head):
# count size of linked list
n = CountSize(head)
# if n is odd
if (n % 2 ! = 0 ):
return 1
else :
o = 0
temp = head
while (temp ! = None ):
if (temp.data = = 1 ):
o + = 1
temp = temp. next
if (o = = (n / / 2 )):
return 1
elif (o % 2 = = 0 ):
return 1
else :
return 0
# Driver Code head = Node( 1 )
head. next = Node( 1 )
head. next . next = Node( 0 )
head. next . next . next = Node( 0 )
print ( "Yes" if (isPossible(head) = = 1 ) else "No" )
# This code is contributed by shinjanpatra |
// C# program to implement above approach using System;
public class Node {
public int data;
public Node next;
public Node( int d)
{
data = d;
next = null ;
} // Constructor
} public class LinkedList{
public Node head;
// Count the size of linked list
public int CountSize()
{
Node temp = head;
int count = 0;
while (temp != null ) {
count++;
temp = temp.next;
}
return count;
}
public Node append(Node node, int val)
{
Node new_node = new Node(val);
node.next = new_node;
return new_node;
}
} public class GFG
{ public static bool isPossible(LinkedList LL)
{
// count size of linked list
int n = LL.CountSize();
// if n is odd
if (n % 2 != 0) {
return true ;
}
else
{
int o = 0;
Node temp = LL.head;
while (temp != null ) {
if (temp.data == 1) {
o++;
}
temp = temp.next;
}
if (o == (n / 2)) {
return true ;
}
else if (o % 2 == 0) {
return true ;
}
else {
return false ;
}
}
}
// Driver Code
public static void Main()
{
LinkedList llist = new LinkedList();
llist.head = new Node(0);
Node cur = llist.head;
cur = llist.append(cur, 0);
cur = llist.append(cur, 1);
cur = llist.append(cur, 1);
if (isPossible(llist))
{
Console.Write( "Yes\n" );
}
else
{
Console.Write( "No\n" );
}
}
} // This code is contributed by subhamgoyal2014. |
<script> // JavaScript code for the above approach
// Node Class
class Node {
constructor(d) {
this .data = d;
this .next = null ;
}
};
// Count the size of linked list
function CountSize(head) {
let temp = head;
let count = 0;
while (temp != null ) {
count++;
temp = temp.next;
}
return count;
}
// Bool function to check
// is it possible to make
// such linked list
function isPossible(head) {
// count size of linked list
let n = CountSize(head);
// if n is odd
if (n % 2 != 0) {
return 1;
}
else {
let o = 0;
let temp = head;
while (temp != null ) {
if (temp.data == 1) {
o++;
}
temp = temp.next;
}
if (o == Math.floor(n / 2)) {
return 1;
}
else if (o % 2 == 0) {
return 1;
}
else {
return 0;
}
}
}
// Driver Code
let head = new Node(1);
head.next = new Node(1);
head.next.next = new Node(0)
head.next.next.next = new Node(0)
document.write((isPossible(head) == 1
? "Yes"
: "No" )
+ '<br>' )
// This code is contributed by Potta Lokesh
</script>
|
Yes
Time Complexity : O(N)
Auxiliary Space : O(1)