Given an array of N elements. The task is to insert the given elements at the middle position in the linked list one after another. Each insert operation should take O(1) time complexity.
Examples:
Input: arr[] = {1, 2, 3, 4, 5}
Output: 1 -> 3 -> 5 -> 4 -> 2 -> NULL
1 -> NULL
1 -> 2 -> NULL
1 -> 3 -> 2 -> NULL
1 -> 3 -> 4 -> 2 -> NULL
1 -> 3 -> 5 -> 4 -> 2 -> NULL
Input: arr[] = {5, 4, 1, 2}
Output: 5 -> 1 -> 2 -> 4 -> NULL
Approach: There are two cases:
- Number of elements present in the list are less than 2.
- Number of elements present in the list are more than 2.
- The number of elements already present are even say N then the new element is inserted in the middle position that is (N / 2) + 1.
- The number of elements already present are odd then the new element is inserted next to the current middle element that is (N / 2) + 2.
We take one additional pointer ‘middle’ which stores the address of current middle element and a counter which counts the total number of elements.
If the elements already present in the linked list are less than 2 then middle will always point to the first position and we insert the new node after the current middle.
If the elements already present in the linked list are more than 2 then we insert the new node next to the current middle and increment the counter.
If there are an odd number of elements after insertion then the middle points to the newly inserted node else there is no change in the middle pointer.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
struct Node {
int value;
struct Node* next;
};
class LinkedList {
private:
struct Node *head, *mid;
int count;
public:
LinkedList();
void insertAtMiddle(int);
void show();
};
LinkedList::LinkedList()
{
head = NULL;
mid = NULL;
count = 0;
}
void LinkedList::insertAtMiddle(int n)
{
struct Node* temp = new struct Node();
struct Node* temp1;
temp->next = NULL;
temp->value = n;
if (count < 2) {
if (head == NULL) {
head = temp;
}
else {
temp1 = head;
temp1->next = temp;
}
count++;
mid = head;
}
else {
temp->next = mid->next;
mid->next = temp;
count++;
if (count % 2 != 0) {
mid = mid->next;
}
}
}
void LinkedList::show()
{
struct Node* temp;
temp = head;
while (temp != NULL) {
cout << temp->value << " -> ";
temp = temp->next;
}
cout << "NULL";
cout << endl;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int n = sizeof(arr) / sizeof(arr[0]);
LinkedList L1;
for (int i = 0; i < n; i++)
L1.insertAtMiddle(arr[i]);
L1.show();
return 0;
}
|
Java
class GFG
{
static class Node
{
int value;
Node next;
};
static class LinkedList
{
Node head, mid;
int count;
LinkedList()
{
head = null;
mid = null;
count = 0;
}
void insertAtMiddle(int n)
{
Node temp = new Node();
Node temp1;
temp.next = null;
temp.value = n;
if (count < 2)
{
if (head == null)
{
head = temp;
}
else
{
temp1 = head;
temp1.next = temp;
}
count++;
mid = head;
}
else
{
temp.next = mid.next;
mid.next = temp;
count++;
if (count % 2 != 0)
{
mid = mid.next;
}
}
}
void show()
{
Node temp;
temp = head;
while (temp != null)
{
System.out.print( temp.value + " -> ");
temp = temp.next;
}
System.out.print( "null");
System.out.println();
}
}
public static void main(String args[])
{
int arr[] = { 1, 2, 3, 4, 5 };
int n = arr.length;
LinkedList L1=new LinkedList();
for (int i = 0; i < n; i++)
L1.insertAtMiddle(arr[i]);
L1.show();
}
}
|
Python3
class Node:
def __init__(self):
self.value = 0
self.next = None
class LinkedList:
def __init__(self) :
self.head = None
self.mid = None
self.count = 0
def insertAtMiddle(self , n):
temp = Node()
temp1 = None
temp.next = None
temp.value = n
if (self.count < 2):
if (self.head == None) :
self.head = temp
else:
temp1 = self.head
temp1.next = temp
self.count = self.count + 1
self.mid = self.head
else:
temp.next = self.mid.next
self.mid.next = temp
self.count = self.count + 1
if (self.count % 2 != 0):
self.mid = self.mid.next
def show(self):
temp = None
temp = self.head
while (temp != None) :
print( temp.value, end = " -> ")
temp = temp.next
print( "None")
arr = [ 1, 2, 3, 4, 5]
n = len(arr)
L1 = LinkedList()
for i in range(n):
L1.insertAtMiddle(arr[i])
L1.show()
|
C#
using System;
class GFG
{
public class Node
{
public int value;
public Node next;
};
public class LinkedList
{
public Node head, mid;
public int count;
public LinkedList()
{
head = null;
mid = null;
count = 0;
}
public void insertAtMiddle(int n)
{
Node temp = new Node();
Node temp1;
temp.next = null;
temp.value = n;
if (count < 2)
{
if (head == null)
{
head = temp;
}
else
{
temp1 = head;
temp1.next = temp;
}
count++;
mid = head;
}
else
{
temp.next = mid.next;
mid.next = temp;
count++;
if (count % 2 != 0)
{
mid = mid.next;
}
}
}
public void show()
{
Node temp;
temp = head;
while (temp != null)
{
Console.Write( temp.value + " -> ");
temp = temp.next;
}
Console.Write( "null");
Console.WriteLine();
}
}
public static void Main(String []args)
{
int []arr = { 1, 2, 3, 4, 5 };
int n = arr.Length;
LinkedList L1=new LinkedList();
for (int i = 0; i < n; i++)
L1.insertAtMiddle(arr[i]);
L1.show();
}
}
|
Javascript
<script>
class Node {
constructor() {
this.value = 0;
this.next = null;
}
}
class LinkedList {
constructor() {
this.head = null;
this.mid = null;
this.count = 0;
}
insertAtMiddle(n) {
var temp = new Node();
var temp1;
temp.next = null;
temp.value = n;
if (this.count < 2) {
if (this.head == null) {
this.head = temp;
} else {
temp1 = this.head;
temp1.next = temp;
}
this.count++;
this.mid = this.head;
}
else {
temp.next = this.mid.next;
this.mid.next = temp;
this.count++;
if (this.count % 2 != 0) {
this.mid = this.mid.next;
}
}
}
show() {
var temp;
temp = this.head;
while (temp != null) {
document.write(temp.value + " -> ");
temp = temp.next;
}
document.write("null");
document.write("<br>");
}
}
var arr = [1, 2, 3, 4, 5];
var n = arr.length;
var L1 = new LinkedList();
for (var i = 0; i < n; i++) L1.insertAtMiddle(arr[i]);
L1.show();
</script>
|
Output: 1 -> 3 -> 5 -> 4 -> 2 -> NULL
Time Complexity : O(N)
Auxiliary Space: O(1), since no extra space has been taken.