Given a Linked List of integers, write a function to modify the linked list such that all even numbers appear before all the odd numbers in the modified linked list. Also, keep the order of even and odd numbers the same.
Examples:
Input: 17->15->8->12->10->5->4->1->7->6->NULL
Output: 8->12->10->4->6->17->15->5->1->7->NULL
Input: 8->12->10->5->4->1->6->NULL
Output: 8->12->10->4->6->5->1->NULL
// If all numbers are even then do not change the list
Input: 8->12->10->NULL
Output: 8->12->10->NULL
// If all numbers are odd then do not change the list
Input: 1->3->5->7->NULL
Output: 1->3->5->7->NULL
Method 1
The idea is to get a pointer to the last node of list. And then traverse the list starting from the head node and move the odd valued nodes from their current position to end of the list.
Follow the steps below to implement the above idea:
- Get a pointer to the last node.
- Move all the odd nodes to the end.
- Consider all odd nodes before the first even node and move them to end.
- Change the head pointer to point to the first even node.
- Consider all odd nodes after the first even node and move them to the end.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
class Node
{
public:
int data;
Node *next;
};
void segregateEvenOdd(Node **head_ref)
{
Node *end = *head_ref;
Node *prev = NULL;
Node *curr = *head_ref;
while (end->next != NULL)
end = end->next;
Node *new_end = end;
while (curr->data % 2 != 0 && curr != end)
{
new_end->next = curr;
curr = curr->next;
new_end->next->next = NULL;
new_end = new_end->next;
}
if (curr->data%2 == 0)
{
*head_ref = curr;
while (curr != end)
{
if ( (curr->data) % 2 == 0 )
{
prev = curr;
curr = curr->next;
}
else
{
prev->next = curr->next;
curr->next = NULL;
new_end->next = curr;
new_end = curr;
curr = prev->next;
}
}
}
else prev = curr;
if (new_end != end && (end->data) % 2 != 0)
{
prev->next = end->next;
end->next = NULL;
new_end->next = end;
}
return;
}
void push(Node** head_ref, int new_data)
{
Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void printList(Node *node)
{
while (node != NULL)
{
cout << node->data <<" ";
node = node->next;
}
}
int main()
{
Node* head = NULL;
push(&head, 11);
push(&head, 10);
push(&head, 8);
push(&head, 6);
push(&head, 4);
push(&head, 2);
push(&head, 0);
cout << "Original Linked list ";
printList(head);
segregateEvenOdd(&head);
cout << "\nModified Linked list ";
printList(head);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct Node
{
int data;
struct Node *next;
};
void segregateEvenOdd(struct Node **head_ref)
{
struct Node *end = *head_ref;
struct Node *prev = NULL;
struct Node *curr = *head_ref;
while (end->next != NULL)
end = end->next;
struct Node *new_end = end;
while (curr->data %2 != 0 && curr != end)
{
new_end->next = curr;
curr = curr->next;
new_end->next->next = NULL;
new_end = new_end->next;
}
if (curr->data%2 == 0)
{
*head_ref = curr;
while (curr != end)
{
if ( (curr->data)%2 == 0 )
{
prev = curr;
curr = curr->next;
}
else
{
prev->next = curr->next;
curr->next = NULL;
new_end->next = curr;
new_end = curr;
curr = prev->next;
}
}
}
else prev = curr;
if (new_end!=end && (end->data)%2 != 0)
{
prev->next = end->next;
end->next = NULL;
new_end->next = end;
}
return;
}
void push(struct Node** head_ref, int new_data)
{
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void printList(struct Node *node)
{
while (node!=NULL)
{
printf("%d ", node->data);
node = node->next;
}
}
int main()
{
struct Node* head = NULL;
push(&head, 11);
push(&head, 10);
push(&head, 8);
push(&head, 6);
push(&head, 4);
push(&head, 2);
push(&head, 0);
printf("\nOriginal Linked list \n");
printList(head);
segregateEvenOdd(&head);
printf("\nModified Linked list \n");
printList(head);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class LinkedList {
Node head;
class Node {
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
void segregateEvenOdd()
{
Node end = head;
Node prev = null;
Node curr = head;
while (end.next != null)
end = end.next;
Node new_end = end;
while (curr.data % 2 != 0 && curr != end) {
new_end.next = curr;
curr = curr.next;
new_end.next.next = null;
new_end = new_end.next;
}
if (curr.data % 2 == 0) {
head = curr;
while (curr != end) {
if (curr.data % 2 == 0) {
prev = curr;
curr = curr.next;
}
else {
prev.next = curr.next;
curr.next = null;
new_end.next = curr;
new_end = curr;
curr = prev.next;
}
}
}
else
prev = curr;
if (new_end != end && end.data % 2 != 0) {
prev.next = end.next;
end.next = null;
new_end.next = end;
}
}
void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
void printList()
{
Node temp = head;
while (temp != null) {
System.out.print(temp.data + " ");
temp = temp.next;
}
System.out.println();
}
public static void main(String args[])
{
LinkedList llist = new LinkedList();
llist.push(11);
llist.push(10);
llist.push(8);
llist.push(6);
llist.push(4);
llist.push(2);
llist.push(0);
System.out.println("Original Linked List");
llist.printList();
llist.segregateEvenOdd();
System.out.println("Modified Linked List");
llist.printList();
}
}
|
Python
head = None
class Node:
def __init__(self, data):
self.data = data
self.next =None
def segregateEvenOdd():
global head
end = head
prev = None
curr = head
while (end.next != None):
end = end.next
new_end = end
while (curr.data % 2 !=0 and curr != end):
new_end.next = curr
curr = curr.next
new_end.next.next = None
new_end = new_end.next
if (curr.data % 2 == 0):
head = curr
while (curr != end):
if (curr.data % 2 == 0):
prev = curr
curr = curr.next
else:
prev.next = curr.next
curr.next = None
new_end.next = curr
new_end = curr
curr = prev.next
else:
prev = curr
if (new_end != end and end.data % 2 != 0):
prev.next = end.next
end.next = None
new_end.next = end
def push(new_data):
global head
new_node = Node(new_data)
new_node.next = head
head = new_node
def printList():
global head
temp = head
while(temp != None):
print(temp.data, end = " ")
temp = temp.next
print(" ")
push(11)
push(10)
push(8)
push(6)
push(4)
push(2)
push(0)
print("Original Linked List")
printList()
segregateEvenOdd()
print("Modified Linked List")
printList()
|
C#
using System;
public class LinkedList
{
Node head;
public class Node
{
public int data;
public Node next;
public Node(int d)
{
data = d;
next = null;
}
}
void segregateEvenOdd()
{
Node end = head;
Node prev = null;
Node curr = head;
while (end.next != null)
end = end.next;
Node new_end = end;
while (curr.data % 2 != 0 && curr != end)
{
new_end.next = curr;
curr = curr.next;
new_end.next.next = null;
new_end = new_end.next;
}
if (curr.data % 2 == 0)
{
head = curr;
while (curr != end)
{
if (curr.data % 2 == 0)
{
prev = curr;
curr = curr.next;
}
else
{
prev.next = curr.next;
curr.next = null;
new_end.next = curr;
new_end = curr;
curr = prev.next;
}
}
}
else prev = curr;
if (new_end != end && end.data % 2 != 0)
{
prev.next = end.next;
end.next = null;
new_end.next = end;
}
}
void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
void printList()
{
Node temp = head;
while(temp != null)
{
Console.Write(temp.data + " ");
temp = temp.next;
}
Console.WriteLine();
}
public static void Main(String []args)
{
LinkedList llist = new LinkedList();
llist.push(11);
llist.push(10);
llist.push(8);
llist.push(6);
llist.push(4);
llist.push(2);
llist.push(0);
Console.WriteLine("Original Linked List");
llist.printList();
llist.segregateEvenOdd();
Console.WriteLine("Modified Linked List");
llist.printList();
}
}
|
Javascript
<script>
var head;
class Node {
constructor(val) {
this.data = val;
this.next = null;
}
}
function segregateEvenOdd() {
var end = head;
var prev = null;
var curr = head;
while (end.next != null)
end = end.next;
var new_end = end;
while (curr.data % 2 != 0 && curr != end) {
new_end.next = curr;
curr = curr.next;
new_end.next.next = null;
new_end = new_end.next;
}
if (curr.data % 2 == 0) {
head = curr;
while (curr != end) {
if (curr.data % 2 == 0) {
prev = curr;
curr = curr.next;
} else {
prev.next = curr.next;
curr.next = null;
new_end.next = curr;
new_end = curr;
curr = prev.next;
}
}
}
else
prev = curr;
if (new_end != end && end.data % 2 != 0) {
prev.next = end.next;
end.next = null;
new_end.next = end;
}
}
function push(new_data) {
var new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
function printList() {
var temp = head;
while (temp != null) {
document.write(temp.data + " ");
temp = temp.next;
}
document.write();
}
push(11);
push(10);
push(8);
push(6);
push(4);
push(2);
push(0);
document.write("Original Linked List ");
printList();
document.write("<br>");
segregateEvenOdd();
document.write("Modified Linked List ");
</script>
|
OutputOriginal Linked list 0 2 4 6 8 10 11
Modified Linked list 0 2 4 6 8 10 11
Time Complexity: O(n), As we are only traversing linearly through the list.
Auxiliary Space: O(1)
Thanks to blunderboy for suggesting this method.
Method 2:
The idea is to split the linked list into two: one containing all even nodes and the other containing all odd nodes. And finally, attach the odd node linked list after the even node linked list.
To split the Linked List, traverse the original Linked List and move all odd nodes to a separate Linked List of all odd nodes. At the end of loop, the original list will have all the even nodes and the odd node list will have all the odd nodes. To keep the ordering of all nodes same, we must insert all the odd nodes at the end of the even node list. And to do that in constant time, we must keep track of last pointer in the even node list.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
void segregateEvenOdd(struct Node** head_ref)
{
Node* evenStart = NULL;
Node* evenEnd = NULL;
Node* oddStart = NULL;
Node* oddEnd = NULL;
Node* currNode = *head_ref;
while (currNode != NULL) {
int val = currNode->data;
if (val % 2 == 0) {
if (evenStart == NULL) {
evenStart = currNode;
evenEnd = evenStart;
}
else {
evenEnd->next = currNode;
evenEnd = evenEnd->next;
}
}
else {
if (oddStart == NULL) {
oddStart = currNode;
oddEnd = oddStart;
}
else {
oddEnd->next = currNode;
oddEnd = oddEnd->next;
}
}
currNode = currNode->next;
}
if (oddStart == NULL || evenStart == NULL)
return;
evenEnd->next = oddStart;
oddEnd->next = NULL;
*head_ref = evenStart;
}
void push(Node** head_ref, int new_data)
{
Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void printList(Node* node)
{
while (node != NULL) {
cout << node->data << " ";
node = node->next;
}
}
int main()
{
Node* head = NULL;
push(&head, 11);
push(&head, 10);
push(&head, 9);
push(&head, 6);
push(&head, 4);
push(&head, 1);
push(&head, 0);
cout << "Original Linked list" << endl;
printList(head);
segregateEvenOdd(&head);
cout << endl << "Modified Linked list " << endl;
printList(head);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node* next;
} Node;
void segregateEvenOdd(Node** head_ref)
{
Node* evenStart = NULL;
Node* evenEnd = NULL;
Node* oddStart = NULL;
Node* oddEnd = NULL;
Node* currNode = *head_ref;
while (currNode != NULL) {
int val = currNode->data;
if (val % 2 == 0) {
if (evenStart == NULL) {
evenStart = currNode;
evenEnd = evenStart;
}
else {
evenEnd->next = currNode,
evenEnd = evenEnd->next;
}
}
else {
if (oddStart == NULL) {
oddStart = currNode;
oddEnd = oddStart;
}
else {
oddEnd->next = currNode;
oddEnd = oddEnd->next;
}
}
currNode = currNode->next;
}
if (oddStart == NULL || evenStart == NULL)
return;
evenEnd->next = oddStart;
oddEnd->next = NULL;
*head_ref = evenStart;
}
void push(Node** head_ref, int new_data)
{
Node* new_node = (Node*)malloc(sizeof(Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void printList(Node* node)
{
while (node != NULL) {
printf("%d ", node->data);
node = node->next;
}
}
int main()
{
struct Node* head = NULL;
push(&head, 11);
push(&head, 10);
push(&head, 9);
push(&head, 6);
push(&head, 4);
push(&head, 1);
push(&head, 0);
printf("\nOriginal Linked list \n");
printList(head);
segregateEvenOdd(&head);
printf("\nModified Linked list \n");
printList(head);
return 0;
}
|
Java
import java.util.*;
import java.io.*;
class LinkedList {
Node head;
class Node
{
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
public void segregateEvenOdd() {
Node evenStart = null;
Node evenEnd = null;
Node oddStart = null;
Node oddEnd = null;
Node currentNode = head;
while(currentNode != null) {
int element = currentNode.data;
if(element % 2 == 0) {
if(evenStart == null) {
evenStart = currentNode;
evenEnd = evenStart;
} else {
evenEnd.next = currentNode;
evenEnd = evenEnd.next;
}
} else {
if(oddStart == null) {
oddStart = currentNode;
oddEnd = oddStart;
} else {
oddEnd.next = currentNode;
oddEnd = oddEnd.next;
}
}
currentNode = currentNode.next;
}
if(oddStart == null || evenStart == null) {
return;
}
evenEnd.next = oddStart;
oddEnd.next = null;
head=evenStart;
}
void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
void printList()
{
Node temp = head;
while(temp != null)
{
System.out.print(temp.data+" ");
temp = temp.next;
}
System.out.println();
}
public static void main(String args[])
{
LinkedList llist = new LinkedList();
llist.push(11);
llist.push(10);
llist.push(9);
llist.push(6);
llist.push(4);
llist.push(1);
llist.push(0);
System.out.println("Original Linked List");
llist.printList();
llist.segregateEvenOdd();
System.out.println("Modified Linked List");
llist.printList();
}
}
|
C#
using System;
public class LinkedList
{
Node head;
public class Node
{
public int data;
public Node next;
public Node(int d)
{
data = d;
next = null;
}
}
public void segregateEvenOdd()
{
Node evenStart = null;
Node evenEnd = null;
Node oddStart = null;
Node oddEnd = null;
Node currentNode = head;
while(currentNode != null)
{
int element = currentNode.data;
if(element % 2 == 0)
{
if(evenStart == null)
{
evenStart = currentNode;
evenEnd = evenStart;
}
else
{
evenEnd.next = currentNode;
evenEnd = evenEnd.next;
}
}
else
{
if(oddStart == null)
{
oddStart = currentNode;
oddEnd = oddStart;
}
else
{
oddEnd.next = currentNode;
oddEnd = oddEnd.next;
}
}
currentNode = currentNode.next;
}
if(oddStart == null || evenStart == null)
{
return;
}
evenEnd.next = oddStart;
oddEnd.next = null;
head=evenStart;
}
void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
void printList()
{
Node temp = head;
while(temp != null)
{
Console.Write(temp.data+" ");
temp = temp.next;
}
Console.WriteLine();
}
public static void Main()
{
LinkedList llist = new LinkedList();
llist.push(11);
llist.push(10);
llist.push(9);
llist.push(6);
llist.push(4);
llist.push(1);
llist.push(0);
Console.WriteLine("Original Linked List");
llist.printList();
llist.segregateEvenOdd();
Console.WriteLine("Modified Linked List");
llist.printList();
}
}
|
Python3
head = None
class Node:
def __init__(self, data):
self.data = data
self.next =None
def segregateEvenOdd():
global head
evenStart = None
evenEnd = None
oddStart = None
oddEnd = None
currNode = head
while(currNode != None):
val = currNode.data
if(val % 2 == 0):
if(evenStart == None):
evenStart = currNode
evenEnd = evenStart
else:
evenEnd . next = currNode
evenEnd = evenEnd . next
else:
if(oddStart == None):
oddStart = currNode
oddEnd = oddStart
else:
oddEnd . next = currNode
oddEnd = oddEnd . next
currNode = currNode . next
if(oddStart == None or evenStart == None):
return
evenEnd . next = oddStart
oddEnd . next = None
head = evenStart
def push(new_data):
global head
new_node = Node(new_data)
new_node.next = head
head = new_node
def printList():
global head
node = head
while (node != None):
print(node.data, end = " ")
node = node.next
print()
push(11)
push(10)
push(9)
push(6)
push(4)
push(1)
push(0)
print("Original Linked list")
printList()
segregateEvenOdd()
print("Modified Linked list")
printList()
|
Javascript
<script>
var head;
class Node {
constructor(val) {
this.data = val;
this.next = null;
}
}
function segregateEvenOdd() {
var evenStart = null;
var evenEnd = null;
var oddStart = null;
var oddEnd = null;
var currentNode = head;
while(currentNode != null) {
var element = currentNode.data;
if(element % 2 == 0) {
if(evenStart == null) {
evenStart = currentNode;
evenEnd = evenStart;
} else {
evenEnd.next = currentNode;
evenEnd = evenEnd.next;
}
} else {
if(oddStart == null) {
oddStart = currentNode;
oddEnd = oddStart;
} else {
oddEnd.next = currentNode;
oddEnd = oddEnd.next;
}
}
currentNode = currentNode.next;
}
if(oddStart == null || evenStart == null) {
return;
}
evenEnd.next = oddStart;
oddEnd.next = null;
head=evenStart;
}
function push(new_data)
{
var new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
function printList()
{
var temp = head;
while(temp != null)
{
document.write(temp.data+" ");
temp = temp.next;
}
document.write("<br/>");
}
push(11);
push(10);
push(9);
push(6);
push(4);
push(1);
push(0);
document.write("Original Linked List<br/>");
printList();
segregateEvenOdd();
document.write("Modified Linked List<br/>");
printList();
</script>
|
OutputOriginal Linked list
0 1 4 6 9 10 11
Modified Linked list
0 4 6 10 1 9 11
Time Complexity: O(n), As we are only traversing linearly through the list.
Auxiliary Space: O(1)
Please write comments if you find the above code/algorithm incorrect, or find other ways to solve the same problem.
Method 3:
Using Queue data structure to solve this problem. Maintaining an even queue and an odd queue to get desired outputs.
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
Node(int x)
{
data = x;
next = NULL;
}
};
void p(Node* node)
{
while (node) {
cout << node->data << " ";
node = node->next;
}
}
Node* divide(Node* head)
{
queue<Node*> qe, qo,q;
Node* cur = head;
while (cur) {
if (cur->data % 2 == 0)
qe.push(cur);
else
qo.push(cur);
cur = cur->next;
}
Node* node = new Node(-100);
Node* ans = node;
while (!qe.empty()) {
q.push(qe.front());
qe.pop();
}
while (!qo.empty()) {
q.push(qo.front());
qo.pop();
}
while (!q.empty()) {
node->next = q.front();
node = q.front();
q.pop();
}
node->next = NULL;
return ans->next;
}
int main()
{
Node* head;
head = new Node(9);
head->next = new Node(1);
head->next->next = new Node(6);
head->next->next->next = new Node(7);
head->next->next->next->next = new Node(3);
head->next->next->next->next->next = new Node(4);
Node* temp = divide(head);
p(temp);
return 0;
}
|
Java
import java.util.*;
class Node{
int data;
Node next;
public Node(int x){
data = x;
next = null;
}
}
class LinkList{
Node head;
void p(Node node){
while(node != null){
System.out.print(node.data + " ");
node = node.next;
}
}
Node divide(Node head){
Queue<Node> qe = new LinkedList<Node>();
Queue<Node> qo = new LinkedList<Node>();
Queue<Node> q = new LinkedList<Node>();
Node cur = head;
while (cur != null){
if(cur.data % 2 == 0)
qe.add(cur);
else
qo.add(cur);
cur = cur.next;
}
Node node = new Node(-100);
Node ans = node;
while(!qe.isEmpty()){
q.add(qe.poll());
}
while(!qo.isEmpty()){
q.add(qo.poll());
}
while(!q.isEmpty()){
node.next = q.poll();
node = node.next;
}
node.next = null;
return ans.next;
}
public static void main(String args[]){
LinkList llist = new LinkList();
llist.head = new Node(9);
llist.head.next = new Node(1);
llist.head.next.next = new Node(6);
llist.head.next.next.next = new Node(7);
llist.head.next.next.next.next = new Node(3);
llist.head.next.next.next.next.next = new Node(4);
Node temp = llist.divide(llist.head);
llist.p(temp);
}
}
|
Python3
class Node:
def __init__(self, x):
self.data = x
self.next = None
def p(node):
while(node is not None):
print(node.data, end=" ")
node = node.next
def divide(head):
q = []
qe = []
qo = []
cur = head
while(cur is not None):
if(cur.data % 2 == 0):
qe.append(cur)
else:
qo.append(cur)
cur = cur.next
node = Node(-100)
ans = node
while(len(qe) > 0):
q.append(qe.pop(0))
while(len(qo) > 0):
q.append(qo.pop(0))
while(len(q) > 0):
node.next = q.pop(0)
node = node.next
node.next = None
return ans.next
head = Node(9)
head.next = Node(1)
head.next.next = Node(6)
head.next.next.next = Node(7)
head.next.next.next.next = Node(3)
head.next.next.next.next.next = Node(4)
temp = divide(head)
p(temp)
|
C#
using System;
using System.Collections.Generic;
public class LinkedList {
public Node head;
public class Node {
public int data;
public Node next;
public Node(int x)
{
data = x;
next = null;
}
}
void p(Node node){
while(node != null){
Console.WriteLine(node.data + " ");
node = node.next;
}
}
Node divide(Node head)
{
Queue<Node> qe = new Queue<Node>();
Queue<Node> qo = new Queue<Node>();
Queue<Node> q = new Queue<Node>();
Node cur = head;
while(cur != null){
if(cur.data%2 == 0)
qe.Enqueue(cur);
else
qo.Enqueue(cur);
cur = cur.next;
}
Node node = new Node(-100);
Node ans = node;
while(qe.Count != 0){
q.Enqueue(qe.Peek());
qe.Dequeue();
}
while(qo.Count != 0){
q.Enqueue(qo.Peek());
qo.Dequeue();
}
while(q.Count != 0){
node.next = q.Peek();
node = q.Peek();
q.Dequeue();
}
node.next = null;
return ans.next;
}
public static void Main(String[] args)
{
LinkedList llist = new LinkedList();
llist.head = new Node(9);
llist.head.next = new Node(1);
llist.head.next.next = new Node(6);
llist.head.next.next.next = new Node(7);
llist.head.next.next.next.next = new Node(3);
llist.head.next.next.next.next.next = new Node(4);
Node temp = llist.divide(llist.head);
llist.p(temp);
}
}
|
Javascript
class Node{
constructor(x){
this.data = x;
this.next = null;
}
}
function p(node){
while(node != null){
document.write(node.data);
node = node.next;
}
}
function divide(head){
var q = [];
var qe = [];
var qo = [];
var cur = head;
while(cur != null){
if(cur.data %2 == 0)
qe.push(cur);
else
qo.push(cur);
cur = cur.next;
}
var node = new Node(-100);
ans = node;
while(qe.length != 0){
q.push(qe.shift());
}
while(qo.length != 0){
q.push(qo.shift());
}
while(q.length != 0){
node.next = q.shift();
node = node.next;
}
node.next = null;
return ans.next;
}
var head = new Node(9);
head.next = new Node(1);
head.next.next = new Node(6);
head.next.next.next = new Node(7);
head.next.next.next.next = new Node(3);
head.next.next.next.next.next = new Node(4);
temp = divide(head);
p(temp);
|
n= no.of nodes
Time Complexity: O(n)
Auxiliary Space: O(n)
// This code is contributed by Abhinav